/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c

Bug Summary

File:	root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c
Warning:	line 1859, column 33 Access to field 'type' results in a dereference of a null pointer (loaded from variable 'src')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -O2 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ggml-c.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +avx -target-feature +avx2 -target-feature +bmi2 -target-feature +f16c -target-feature +fma -target-feature +sse4.2 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/third_party/llama.cpp -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/third_party/llama.cpp -resource-dir /usr/lib/llvm-23/lib/clang/23 -include /root/firefox-clang/config/gcc_hidden.h -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG=1 -D _GNU_SOURCE=1 -D GGML_USE_CPU=1 -D GGML_VERSION="GGML_VERSION" -D GGML_COMMIT="GGML_COMMIT" -D GGML_SHARED=1 -D LLAMA_SHARED=1 -D GGML_BUILD=1 -D LLAMA_BUILD=1 -D GGML_BACKEND_SHARED=1 -D GGML_BACKEND_BUILD=1 -D MOZ_HAS_MOZGLUE -I /root/firefox-clang/third_party/llama.cpp -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/third_party/llama.cpp -I /root/firefox-clang/third_party/llama.cpp/ggml -I /root/firefox-clang/third_party/llama.cpp/ggml/include -I /root/firefox-clang/third_party/llama.cpp/ggml/src -I /root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-cpu -I /root/firefox-clang/third_party/llama.cpp/include -I /root/firefox-clang/third_party/llama.cpp/src -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/llvm-23/lib/clang/23/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-error=tautological-type-limit-compare -Wno-range-loop-analysis -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-unknown-warning-option -Wno-character-conversion -Wno-sign-compare -Wno-unused-function -Wno-unreachable-code -Wno-tautological-unsigned-enum-zero-compare -Wno-absolute-value -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fdiagnostics-absolute-paths -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -mllvm -dwarf-linkage-names=Abstract -faddrsig -fdwarf2-cfi-asm -o /tmp/scan-build-2026-09-01-224014-2642839-1 -x c /root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c
1#define _CRT_SECURE_NO_DEPRECATE // Disables "unsafe" warnings on Windows
2#define _USE_MATH_DEFINES // For M_PI on MSVC

4#include "ggml-backend.h"
5#include "ggml-impl.h"
6#include "ggml-threading.h"
7#include "ggml-cpu.h"
8#include "ggml.h"

10// FIXME: required here for quantization functions
11#include "ggml-quants.h"

13#ifdef GGML_USE_CPU_HBM
14#include <hbwmalloc.h>
15#endif

17#if defined(_MSC_VER) || defined(__MINGW32__)
18#include <malloc.h> // using malloc.h with MSC/MINGW
19#elif !defined(__FreeBSD__) && !defined(__NetBSD__) && !defined(__OpenBSD__)
20#include <alloca.h>
21#endif

23#include <assert.h>
24#include <errno(*__errno_location ()).h>
25#include <time.h>
26#include <math.h>
27#include <stdlib.h>
28#include <string.h>
29#include <stdint.h>
30#include <inttypes.h>
31#include <stdio.h>
32#include <float.h>
33#include <limits.h>
34#include <stdarg.h>
35#include <signal.h>
36#if defined(__gnu_linux__1)
37#include <syscall.h>
38#endif

40#if defined(__APPLE__)
41#include <unistd.h>
42#include <mach/mach.h>
43#include <TargetConditionals.h>
44#endif

46#if defined(_WIN32)
47#define WIN32_LEAN_AND_MEAN
48#ifndef NOMINMAX
  #define NOMINMAX
50#endif
51#include <windows.h>
52#endif

54#define UNUSEDGGML_UNUSED GGML_UNUSED

56uint64_t ggml_graph_next_uid(void) {
57#ifdef _MSC_VER
58#if defined(_WIN32)
  static volatile LONG counter = 1;
  return (uint64_t) InterlockedIncrement(&counter) - 1;
61#else
  static volatile long long counter = 1;
  return (uint64_t) _InterlockedIncrement64(&counter) - 1;
64#endif
65#else
  static uint64_t counter = 1;
  return __atomic_fetch_add(&counter, 1, __ATOMIC_RELAXED0);
68#endif
69}

71// Needed for ggml_fp32_to_bf16_row()
72#if defined(__AVX512BF16__)
73#if defined(_MSC_VER)
74#define m512i(p) p
75#else
76#include <immintrin.h>
77#define m512i(p) (__m512i)(p)
78#endif // defined(_MSC_VER)
79#endif // defined(__AVX512BF16__)

81#if defined(__linux__1) || \
  defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || \
  (defined(__APPLE__) && !TARGET_OS_TV && !TARGET_OS_WATCH)

85#include <unistd.h>
86#include <sys/types.h>
87#include <sys/stat.h>
88#include <sys/wait.h>
89#if defined(__linux__1)
90#include <sys/prctl.h>
91#endif

93#if defined(__ANDROID__)
94#include <unwind.h>
95#include <dlfcn.h>
96#include <stdio.h>

98struct backtrace_state {
  void ** current;
  void ** end;
101};

103static _Unwind_Reason_Code unwind_callback(struct _Unwind_Context* context, void* arg) {
  struct backtrace_state * state = (struct backtrace_state *)arg;
  uintptr_t pc = _Unwind_GetIP(context);
  if (pc) {
      if (state->current == state->end) {
          return _URC_END_OF_STACK;
      } else {
          *state->current++ = (void*)pc;
      }
  }
  return _URC_NO_REASON;
114}

116static void ggml_print_backtrace_symbols(void) {
  const int max = 100;
  void* buffer[max];

  struct backtrace_state state = {buffer, buffer + max};
  _Unwind_Backtrace(unwind_callback, &state);

  int count = state.current - buffer;

  for (int idx = 0; idx < count; ++idx) {
      const void * addr = buffer[idx];
      const char * symbol = "";

      Dl_info info;
      if (dladdr(addr, &info) && info.dli_sname) {
          symbol = info.dli_sname;
      }

      fprintf(stderrstderr, "%d: %p %s\n", idx, addr, symbol);
  }
136}
137#elif defined(__linux__1) && defined(__GLIBC__2)
138#include <execinfo.h>
139static void ggml_print_backtrace_symbols(void) {
  void * trace[100];
  int nptrs = backtrace(trace, sizeof(trace)/sizeof(trace[0]));
  backtrace_symbols_fd(trace, nptrs, STDERR_FILENO2);
143}
144#elif defined(__APPLE__)
145#include <execinfo.h>
146static void ggml_print_backtrace_symbols(void) {
  void * trace[100];
  int nptrs = backtrace(trace, sizeof(trace)/sizeof(trace[0]));
  backtrace_symbols_fd(trace, nptrs, STDERR_FILENO2);
150}
151#else
152static void ggml_print_backtrace_symbols(void) {
  // platform not supported
154}
155#endif

157void ggml_print_backtrace(void) {
  const char * GGML_NO_BACKTRACE = getenv("GGML_NO_BACKTRACE");
  if (GGML_NO_BACKTRACE) {
      return;
  }
162#if defined(__APPLE__)
  // On macOS, fork+debugger attachment is problematic due to:
  // 1. libdispatch "poisons" forked child processes
  // 2. lldb has issues attaching to parent from forked child
  // Use simple backtrace() instead to avoid Terminal.app crashes
  const char * GGML_BACKTRACE_LLDB = getenv("GGML_BACKTRACE_LLDB");
  if (!GGML_BACKTRACE_LLDB) {
      fprintf(stderrstderr, "WARNING: Using native backtrace. Set GGML_BACKTRACE_LLDB for more info.\n");
      fprintf(stderrstderr, "WARNING: GGML_BACKTRACE_LLDB may cause native MacOS Terminal.app to crash.\n");
      fprintf(stderrstderr, "See: https://github.com/ggml-org/llama.cpp/pull/17869\n");
      ggml_print_backtrace_symbols();
      return;
  }
175#endif
176#if defined(__linux__1)
  FILE * f = fopen("/proc/self/status", "r");
  size_t size = 0;
  char * line = NULL((void*)0);
  ssize_t length = 0;
  while ((length = getline(&line, &size, f)) > 0) {
      if (!strncmp(line, "TracerPid:", sizeof("TracerPid:") - 1) &&
          (length != sizeof("TracerPid:\t0\n") - 1 || line[length - 2] != '0')) {
          // Already being debugged, and the breakpoint is the later abort()
          free(line);
          fclose(f);
          return;
      }
  }
  free(line);
  fclose(f);
  int lock[2] = { -1, -1 };
  (void) !pipe(lock); // Don't start gdb until after PR_SET_PTRACER
194#endif
  const int parent_pid = getpid();
  const int child_pid = fork();
  if (child_pid < 0) { // error
198#if defined(__linux__1)
      close(lock[1]);
      close(lock[0]);
201#endif
      return;
  } else if (child_pid == 0) { // child
      char attach[32];
      snprintf(attach, sizeof(attach), "attach %d", parent_pid);
206#if defined(__linux__1)
      close(lock[1]);
      (void) !read(lock[0], lock, 1);
      close(lock[0]);
210#endif
      // try gdb
      execlp("gdb", "gdb", "--batch",
          "-ex", "set style enabled on",
          "-ex", attach,
          "-ex", "bt -frame-info source-and-location",
          "-ex", "detach",
          "-ex", "quit",
          (char *) NULL((void*)0));
      // try lldb
      execlp("lldb", "lldb", "--batch",
          "-o", "bt",
          "-o", "quit",
          "-p", &attach[sizeof("attach ") - 1],
          (char *) NULL((void*)0));
      // gdb failed, fallback to backtrace_symbols
      ggml_print_backtrace_symbols();
      _Exit(0);
  } else { // parent
229#if defined(__linux__1)
      prctl(PR_SET_PTRACER0x59616d61, child_pid);
      close(lock[1]);
      close(lock[0]);
233#endif
      waitpid(child_pid, NULL((void*)0), 0);
  }
236}
237#else
238void ggml_print_backtrace(void) {
  // platform not supported
240}
241#endif

243static ggml_abort_callback_t g_abort_callback = NULL((void*)0);

245// Set the abort callback (passing null will restore original abort functionality: printing a message to stdout)
246GGML_API__attribute__ ((visibility ("default"))) extern ggml_abort_callback_t ggml_set_abort_callback(ggml_abort_callback_t callback) {
  ggml_abort_callback_t ret_val = g_abort_callback;
  g_abort_callback = callback;
  return ret_val;
250}

252void ggml_abort(const char * file, int line, const char * fmt, ...) {
  fflush(stdoutstdout);

  char message[2048];
  int offset = snprintf(message, sizeof(message), "%s:%d: ", file, line);

  va_list args;
  va_start(args, fmt)__builtin_va_start(args, fmt);
  vsnprintf(message + offset, sizeof(message) - offset, fmt, args);
  va_end(args)__builtin_va_end(args);

  if (g_abort_callback) {
      g_abort_callback(message);
  } else {
      // default: print error and backtrace to stderr
      fprintf(stderrstderr, "%s\n", message);
      ggml_print_backtrace();
  }

  abort();
272}

274// ggml_print_backtrace is registered with std::set_terminate by ggml.cpp

276//
277// logging
278//

280struct ggml_logger_state {
  ggml_log_callback log_callback;
  void * log_callback_user_data;
283};
284static struct ggml_logger_state g_logger_state = {ggml_log_callback_default, NULL((void*)0)};

286static void ggml_log_internal_v(enum ggml_log_level level, const char * format, va_list args) {
  if (format == NULL((void*)0)) {
      return;
  }
  va_list args_copy;
  va_copy(args_copy, args)__builtin_va_copy(args_copy, args);
  char buffer[128];
  int len = vsnprintf(buffer, 128, format, args);
  if (len < 128) {
      g_logger_state.log_callback(level, buffer, g_logger_state.log_callback_user_data);
  } else {
      char * buffer2 = (char *) calloc(len + 1, sizeof(char));
      vsnprintf(buffer2, len + 1, format, args_copy);
      buffer2[len] = 0;
      g_logger_state.log_callback(level, buffer2, g_logger_state.log_callback_user_data);
      free(buffer2);
  }
  va_end(args_copy)__builtin_va_end(args_copy);
304}

306void ggml_log_internal(enum ggml_log_level level, const char * format, ...) {
  va_list args;
  va_start(args, format)__builtin_va_start(args, format);
  ggml_log_internal_v(level, format, args);
  va_end(args)__builtin_va_end(args);
311}

313void ggml_log_callback_default(enum ggml_log_level level, const char * text, void * user_data) {
  (void) level;
  (void) user_data;
  fputs(text, stderrstderr);
  fflush(stderrstderr);
318}

320//
321// end of logging block
322//

324#ifdef GGML_USE_ACCELERATE
325// uncomment to use vDSP for soft max computation
326// note: not sure if it is actually faster
327//#define GGML_SOFT_MAX_ACCELERATE
328#endif


331void * ggml_aligned_malloc(size_t size) {
332#if defined(__s390x__)
  const int alignment = 256;
334#else
  const int alignment = 64;
336#endif

338#if defined(_MSC_VER) || defined(__MINGW32__)
  return _aligned_malloc(size, alignment);
340#else
  if (size == 0) {
      GGML_LOG_WARN("Behavior may be unexpected when allocating 0 bytes for ggml_aligned_malloc!\n")ggml_log_internal(GGML_LOG_LEVEL_WARN , "Behavior may be unexpected when allocating 0 bytes for ggml_aligned_malloc!\n"
);
      return NULL((void*)0);
  }
  void * aligned_memory = NULL((void*)0);
#ifdef GGML_USE_CPU_HBM
  int result = hbw_posix_memalign(&aligned_memory, alignment, size);
#elif TARGET_OS_OSX
  GGML_UNUSED(alignment)(void)(alignment);
  kern_return_t alloc_status = vm_allocate((vm_map_t) mach_task_self(), (vm_address_t *) &aligned_memory, size, VM_FLAGS_ANYWHERE);
  int result = EFAULT14;
  switch (alloc_status) {
      case KERN_SUCCESS:
          result = 0;
          break;
      case KERN_INVALID_ADDRESS:
          result = EINVAL22;
          break;
      case KERN_NO_SPACE:
          result = ENOMEM12;
          break;
      default:
          result = EFAULT14;
          break;
  }
#else
  int result = posix_memalign(&aligned_memory, alignment, size);
#endif
  if (result != 0) {
      // Handle allocation failure
      const char *error_desc = "unknown allocation error";
      switch (result) {
          case EINVAL22:
              error_desc = "invalid alignment value";
              break;
          case ENOMEM12:
              error_desc = "insufficient memory";
              break;
      }
      GGML_LOG_ERROR("%s: %s (attempted to allocate %6.2f MB)\n", __func__, error_desc, size/(1024.0*1024.0))ggml_log_internal(GGML_LOG_LEVEL_ERROR, "%s: %s (attempted to allocate %6.2f MB)\n"
, __func__, error_desc, size/(1024.0*1024.0));
      return NULL((void*)0);
  }
  return aligned_memory;
384#endif
385}

387void ggml_aligned_free(void * ptr, size_t size) {
  GGML_UNUSED(size)(void)(size);
389#if defined(_MSC_VER) || defined(__MINGW32__)
  _aligned_free(ptr);
391#elif GGML_USE_CPU_HBM
  if (ptr != NULL((void*)0)) {
      hbw_free(ptr);
  }
395#elif TARGET_OS_OSX
  if (ptr != NULL((void*)0)) {
      vm_deallocate((vm_map_t)mach_task_self(), (vm_address_t)ptr, size);
  }
399#else
  free(ptr);
401#endif
402}


405inline static void * ggml_malloc(size_t size) {
  if (size == 0) {
      GGML_LOG_WARN("Behavior may be unexpected when allocating 0 bytes for ggml_malloc!\n")ggml_log_internal(GGML_LOG_LEVEL_WARN , "Behavior may be unexpected when allocating 0 bytes for ggml_malloc!\n"
);
      return NULL((void*)0);
  }
  void * result = malloc(size);
  if (result == NULL((void*)0)) {
      GGML_LOG_ERROR("%s: failed to allocate %6.2f MB\n", __func__, size/(1024.0*1024.0))ggml_log_internal(GGML_LOG_LEVEL_ERROR, "%s: failed to allocate %6.2f MB\n"
, __func__, size/(1024.0*1024.0));
      GGML_ABORT("fatal error")ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 413, "fatal error");
  }
  return result;
416}

418// calloc
419inline static void * ggml_calloc(size_t num, size_t size) {
  if (num == 0 || size == 0) {
      GGML_LOG_WARN("Behavior may be unexpected when allocating 0 bytes for ggml_calloc!\n")ggml_log_internal(GGML_LOG_LEVEL_WARN , "Behavior may be unexpected when allocating 0 bytes for ggml_calloc!\n"
);
      return NULL((void*)0);
  }
  void * result = calloc(num, size);
  if (result == NULL((void*)0)) {
      GGML_LOG_ERROR("%s: failed to allocate %6.2f MB\n", __func__, size/(1024.0*1024.0))ggml_log_internal(GGML_LOG_LEVEL_ERROR, "%s: failed to allocate %6.2f MB\n"
, __func__, size/(1024.0*1024.0));
      GGML_ABORT("fatal error")ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 427, "fatal error");
  }
  return result;
430}

432#define GGML_MALLOC(size)ggml_malloc(size)      ggml_malloc(size)
433#define GGML_CALLOC(num, size)ggml_calloc(num, size) ggml_calloc(num, size)

435#define GGML_FREE(ptr)free(ptr) free(ptr)

437const char * ggml_status_to_string(enum ggml_status status) {
  switch (status) {
      case GGML_STATUS_ALLOC_FAILED: return "GGML status: error (failed to allocate memory)";
      case GGML_STATUS_FAILED:       return "GGML status: error (operation failed)";
      case GGML_STATUS_SUCCESS:      return "GGML status: success";
      case GGML_STATUS_ABORTED:      return "GGML status: warning (operation aborted)";
  }

  return "GGML status: unknown";
446}

448float ggml_fp16_to_fp32do_not_use__ggml_fp16_to_fp32__in_ggml(ggml_fp16_t x) {
449#define ggml_fp16_to_fp32do_not_use__ggml_fp16_to_fp32__in_ggml do_not_use__ggml_fp16_to_fp32__in_ggml
  return GGML_FP16_TO_FP32(x)ggml_compute_fp16_to_fp32(x);
451}

453ggml_fp16_t ggml_fp32_to_fp16do_not_use__ggml_fp32_to_fp16__in_ggml(float x) {
454#define ggml_fp32_to_fp16do_not_use__ggml_fp32_to_fp16__in_ggml do_not_use__ggml_fp32_to_fp16__in_ggml
  return GGML_FP32_TO_FP16(x)ggml_compute_fp32_to_fp16(x);
456}

458float ggml_bf16_to_fp32do_not_use__ggml_bf16_to_fp32__in_ggml(ggml_bf16_t x) {
459#define ggml_bf16_to_fp32do_not_use__ggml_bf16_to_fp32__in_ggml do_not_use__ggml_bf16_to_fp32__in_ggml
  return GGML_BF16_TO_FP32(x)ggml_compute_bf16_to_fp32(x);  // it just left shifts
461}

463ggml_bf16_t ggml_fp32_to_bf16do_not_use__ggml_fp32_to_bf16__in_ggml(float x) {
464#define ggml_fp32_to_bf16do_not_use__ggml_fp32_to_bf16__in_ggml do_not_use__ggml_fp32_to_bf16__in_ggml
  return GGML_FP32_TO_BF16(x)ggml_compute_fp32_to_bf16(x);
466}

468void ggml_fp16_to_fp32_row(const ggml_fp16_t * x, float * y, int64_t n) {
  for (int64_t i = 0; i < n; i++) {
      y[i] = GGML_FP16_TO_FP32(x[i])ggml_compute_fp16_to_fp32(x[i]);
  }
472}

474void ggml_fp32_to_fp16_row(const float * x, ggml_fp16_t * y, int64_t n) {
  int i = 0;
  for (; i < n; ++i) {
      y[i] = GGML_FP32_TO_FP16(x[i])ggml_compute_fp32_to_fp16(x[i]);
  }
479}

481void ggml_bf16_to_fp32_row(const ggml_bf16_t * x, float * y, int64_t n) {
  int i = 0;
  for (; i < n; ++i) {
      y[i] = GGML_BF16_TO_FP32(x[i])ggml_compute_bf16_to_fp32(x[i]);
  }
486}

488void ggml_fp32_to_bf16_row_ref(const float * x, ggml_bf16_t * y, int64_t n) {
  for (int i = 0; i < n; i++) {
      y[i] = ggml_compute_fp32_to_bf16(x[i]);
  }
492}

494void ggml_fp32_to_bf16_row(const float * x, ggml_bf16_t * y, int64_t n) {
int i = 0;
496#if defined(__AVX512BF16__)
// subnormals are flushed to zero on this platform
for (; i + 32 <= n; i += 32) {
      _mm512_storeu_si512(
          (__m512i *)(y + i),
          m512i(_mm512_cvtne2ps_pbh(_mm512_loadu_ps(x + i + 16),
                              _mm512_loadu_ps(x + i))));
}
504#endif
  for (; i < n; i++) {
      y[i] = GGML_FP32_TO_BF16(x[i])ggml_compute_fp32_to_bf16(x[i]);
  }
508}

510bool_Bool ggml_guid_matches(ggml_guid_t guid_a, ggml_guid_t guid_b) {
  return memcmp(guid_a, guid_b, sizeof(ggml_guid)) == 0;
512}

514const char * ggml_version(void) {
  return GGML_VERSION"GGML_VERSION";
516}

518const char * ggml_commit(void) {
  return GGML_COMMIT"GGML_COMMIT";
520}

522//
523// timing
524//

526#if defined(_MSC_VER) || defined(__MINGW32__)
527static int64_t timer_freq, timer_start;
528void ggml_time_init(void) {
  LARGE_INTEGER t;
  QueryPerformanceFrequency(&t);
  timer_freq = t.QuadPart;

  // The multiplication by 1000 or 1000000 below can cause an overflow if timer_freq
  // and the uptime is high enough.
  // We subtract the program start time to reduce the likelihood of that happening.
  QueryPerformanceCounter(&t);
  timer_start = t.QuadPart;
538}
539int64_t ggml_time_ms(void) {
  LARGE_INTEGER t;
  QueryPerformanceCounter(&t);
  return ((t.QuadPart-timer_start) * 1000) / timer_freq;
543}
544int64_t ggml_time_us(void) {
  LARGE_INTEGER t;
  QueryPerformanceCounter(&t);
  return ((t.QuadPart-timer_start) * 1000000) / timer_freq;
548}
549#else
550void ggml_time_init(void) {}
551int64_t ggml_time_ms(void) {
  struct timespec ts;
  clock_gettime(CLOCK_MONOTONIC1, &ts);
  return (int64_t)ts.tv_sec*1000 + (int64_t)ts.tv_nsec/1000000;
555}

557int64_t ggml_time_us(void) {
  struct timespec ts;
  clock_gettime(CLOCK_MONOTONIC1, &ts);
  return (int64_t)ts.tv_sec*1000000 + (int64_t)ts.tv_nsec/1000;
561}
562#endif

564int64_t ggml_cycles(void) {
  return clock();
566}

568int64_t ggml_cycles_per_ms(void) {
  return CLOCKS_PER_SEC((__clock_t) 1000000)/1000;
570}

572//
573// cross-platform UTF-8 file paths
574//

576#ifdef _WIN32
577static wchar_t * ggml_mbstowcs(const char * mbs) {
  int wlen = MultiByteToWideChar(CP_UTF8, 0, mbs, -1, NULL((void*)0), 0);
  if (!wlen) {
      errno(*__errno_location ()) = EINVAL22;
      return NULL((void*)0);
  }

  wchar_t * wbuf = GGML_MALLOC(wlen * sizeof(wchar_t))ggml_malloc(wlen * sizeof(wchar_t));
  wlen = MultiByteToWideChar(CP_UTF8, 0, mbs, -1, wbuf, wlen);
  if (!wlen) {
      GGML_FREE(wbuf)free(wbuf);
      errno(*__errno_location ()) = EINVAL22;
      return NULL((void*)0);
  }

  return wbuf;
593}
594#endif

596FILE * ggml_fopen(const char * fname, const char * mode) {
597#ifdef _WIN32
  FILE * file = NULL((void*)0);

  // convert fname (UTF-8)
  wchar_t * wfname = ggml_mbstowcs(fname);
  if (wfname) {
      // convert mode (ANSI)
      wchar_t * wmode = GGML_MALLOC((strlen(mode) + 1) * sizeof(wchar_t))ggml_malloc((strlen(mode) + 1) * sizeof(wchar_t));
      wchar_t * wmode_p = wmode;
      do {
          *wmode_p++ = (wchar_t)*mode;
      } while (*mode++);

      // open file
      file = _wfopen(wfname, wmode);

      GGML_FREE(wfname)free(wfname);
      GGML_FREE(wmode)free(wmode);
  }

  return file;
618#else
  return fopen(fname, mode);
620#endif

622}

624static const struct ggml_type_traits type_traits[GGML_TYPE_COUNT] = {
  [GGML_TYPE_I8] = {
      .type_name                = "i8",
      .blck_size                = 1,
      .type_size                = sizeof(int8_t),
      .is_quantized             = false0,
  },
  [GGML_TYPE_I16] = {
      .type_name                = "i16",
      .blck_size                = 1,
      .type_size                = sizeof(int16_t),
      .is_quantized             = false0,
  },
  [GGML_TYPE_I32] = {
      .type_name                = "i32",
      .blck_size                = 1,
      .type_size                = sizeof(int32_t),
      .is_quantized             = false0,
  },
  [GGML_TYPE_I64] = {
      .type_name                = "i64",
      .blck_size                = 1,
      .type_size                = sizeof(int64_t),
      .is_quantized             = false0,
  },
  [GGML_TYPE_F64] = {
      .type_name                = "f64",
      .blck_size                = 1,
      .type_size                = sizeof(double),
      .is_quantized             = false0,
  },
  [GGML_TYPE_F32] = {
      .type_name                = "f32",
      .blck_size                = 1,
      .type_size                = sizeof(float),
      .is_quantized             = false0,
  },
  [GGML_TYPE_F16] = {
      .type_name                = "f16",
      .blck_size                = 1,
      .type_size                = sizeof(ggml_fp16_t),
      .is_quantized             = false0,
      .to_float                 = (ggml_to_float_t) ggml_fp16_to_fp32_row,
      .from_float_ref           = (ggml_from_float_t) ggml_fp32_to_fp16_row,
  },
  [GGML_TYPE_Q1_0] = {
      .type_name                = "q1_0",
      .blck_size                = QK1_0128,
      .type_size                = sizeof(block_q1_0),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_q1_0,
      .from_float_ref           = (ggml_from_float_t) quantize_row_q1_0_ref,
  },
  [GGML_TYPE_Q4_0] = {
      .type_name                = "q4_0",
      .blck_size                = QK4_032,
      .type_size                = sizeof(block_q4_0),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_q4_0,
      .from_float_ref           = (ggml_from_float_t) quantize_row_q4_0_ref,
  },
  [GGML_TYPE_Q4_1] = {
      .type_name                = "q4_1",
      .blck_size                = QK4_132,
      .type_size                = sizeof(block_q4_1),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_q4_1,
      .from_float_ref           = (ggml_from_float_t) quantize_row_q4_1_ref,
  },
  [4] = { // GGML_TYPE_Q4_2
      .type_name                = "DEPRECATED",
      .blck_size                = 0,
      .type_size                = 0,
      .is_quantized             = false0,
  },
  [5] = { // GGML_TYPE_Q4_3
      .type_name                = "DEPRECATED",
      .blck_size                = 0,
      .type_size                = 0,
      .is_quantized             = false0,
  },
  [GGML_TYPE_Q5_0] = {
      .type_name                = "q5_0",
      .blck_size                = QK5_032,
      .type_size                = sizeof(block_q5_0),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_q5_0,
      .from_float_ref           = (ggml_from_float_t) quantize_row_q5_0_ref,
  },
  [GGML_TYPE_Q5_1] = {
      .type_name                = "q5_1",
      .blck_size                = QK5_132,
      .type_size                = sizeof(block_q5_1),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_q5_1,
      .from_float_ref           = (ggml_from_float_t) quantize_row_q5_1_ref,
  },
  [GGML_TYPE_Q8_0] = {
      .type_name                = "q8_0",
      .blck_size                = QK8_032,
      .type_size                = sizeof(block_q8_0),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_q8_0,
      .from_float_ref           = (ggml_from_float_t) quantize_row_q8_0_ref,
  },
  [GGML_TYPE_Q8_1] = {
      .type_name                = "q8_1",
      .blck_size                = QK8_132,
      .type_size                = sizeof(block_q8_1),
      .is_quantized             = true1,
      .from_float_ref           = (ggml_from_float_t) quantize_row_q8_1_ref,
  },
  [GGML_TYPE_MXFP4] = {
      .type_name                = "mxfp4",
      .blck_size                = QK_MXFP432,
      .type_size                = sizeof(block_mxfp4),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_mxfp4,
      .from_float_ref           = (ggml_from_float_t)quantize_row_mxfp4_ref,
  },
  [GGML_TYPE_NVFP4] = {
      .type_name                = "nvfp4",
      .blck_size                = QK_NVFP464,
      .type_size                = sizeof(block_nvfp4),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_nvfp4,
      .from_float_ref           = (ggml_from_float_t)quantize_row_nvfp4_ref,
  },
  [GGML_TYPE_Q2_K] = {
      .type_name                = "q2_K",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_q2_K),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_q2_K,
      .from_float_ref           = (ggml_from_float_t) quantize_row_q2_K_ref,
  },
  [GGML_TYPE_Q3_K] = {
      .type_name                = "q3_K",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_q3_K),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_q3_K,
      .from_float_ref           = (ggml_from_float_t) quantize_row_q3_K_ref,
  },
  [GGML_TYPE_Q4_K] = {
      .type_name                = "q4_K",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_q4_K),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_q4_K,
      .from_float_ref           = (ggml_from_float_t) quantize_row_q4_K_ref,
  },
  [GGML_TYPE_Q5_K] = {
      .type_name                = "q5_K",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_q5_K),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_q5_K,
      .from_float_ref           = (ggml_from_float_t) quantize_row_q5_K_ref,
  },
  [GGML_TYPE_Q6_K] = {
      .type_name                = "q6_K",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_q6_K),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_q6_K,
      .from_float_ref           = (ggml_from_float_t) quantize_row_q6_K_ref,
  },
  [GGML_TYPE_IQ2_XXS] = {
      .type_name                = "iq2_xxs",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_iq2_xxs),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_iq2_xxs,
      .from_float_ref           = NULL((void*)0),
  },
  [GGML_TYPE_IQ2_XS] = {
      .type_name                = "iq2_xs",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_iq2_xs),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_iq2_xs,
      .from_float_ref           = NULL((void*)0),
  },
  [GGML_TYPE_IQ3_XXS] = {
      .type_name                = "iq3_xxs",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_iq3_xxs),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_iq3_xxs,
      .from_float_ref           = (ggml_from_float_t)quantize_row_iq3_xxs_ref,
  },
  [GGML_TYPE_IQ3_S] = {
      .type_name                = "iq3_s",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_iq3_s),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_iq3_s,
      .from_float_ref           = (ggml_from_float_t)quantize_row_iq3_s_ref,
  },
  [GGML_TYPE_IQ2_S] = {
      .type_name                = "iq2_s",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_iq2_s),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_iq2_s,
      .from_float_ref           = (ggml_from_float_t)quantize_row_iq2_s_ref,
  },
  [GGML_TYPE_IQ1_S] = {
      .type_name                = "iq1_s",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_iq1_s),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_iq1_s,
      .from_float_ref           = NULL((void*)0),
  },
  [GGML_TYPE_IQ1_M] = {
      .type_name                = "iq1_m",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_iq1_m),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_iq1_m,
      .from_float_ref           = NULL((void*)0),
  },
  [GGML_TYPE_IQ4_NL] = {
      .type_name                = "iq4_nl",
      .blck_size                = QK4_NL32,
      .type_size                = sizeof(block_iq4_nl),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_iq4_nl,
      .from_float_ref           = (ggml_from_float_t)quantize_row_iq4_nl_ref,
  },
  [GGML_TYPE_IQ4_XS] = {
      .type_name                = "iq4_xs",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_iq4_xs),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_iq4_xs,
      .from_float_ref           = (ggml_from_float_t)quantize_row_iq4_xs_ref,
  },
  [GGML_TYPE_Q8_K] = {
      .type_name                = "q8_K",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_q8_K),
      .is_quantized             = true1,
  },
  [GGML_TYPE_BF16] = {
      .type_name                = "bf16",
      .blck_size                = 1,
      .type_size                = sizeof(ggml_bf16_t),
      .is_quantized             = false0,
      .to_float                 = (ggml_to_float_t) ggml_bf16_to_fp32_row,
      .from_float_ref           = (ggml_from_float_t) ggml_fp32_to_bf16_row_ref,
  },
  [31] = { // GGML_TYPE_Q4_0_4_4
      .type_name                = "TYPE_Q4_0_4_4 REMOVED, use Q4_0 with runtime repacking",
      .blck_size                = 0,
      .type_size                = 0,
      .is_quantized             = false0,
  },
  [32] = { // GGML_TYPE_Q4_0_4_8
      .type_name                = "TYPE_Q4_0_4_8 REMOVED, use Q4_0 with runtime repacking",
      .blck_size                = 0,
      .type_size                = 0,
      .is_quantized             = false0,
  },
  [33] = { // GGML_TYPE_Q4_0_8_8
      .type_name                = "TYPE_Q4_0_8_8 REMOVED, use Q4_0 with runtime repacking",
      .blck_size                = 0,
      .type_size                = 0,
      .is_quantized             = false0,
  },
  [GGML_TYPE_TQ1_0] = {
      .type_name                = "tq1_0",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_tq1_0),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_tq1_0,
      .from_float_ref           = (ggml_from_float_t) quantize_row_tq1_0_ref,
  },
  [GGML_TYPE_TQ2_0] = {
      .type_name                = "tq2_0",
      .blck_size                = QK_K256,
      .type_size                = sizeof(block_tq2_0),
      .is_quantized             = true1,
      .to_float                 = (ggml_to_float_t) dequantize_row_tq2_0,
      .from_float_ref           = (ggml_from_float_t) quantize_row_tq2_0_ref,
  },
  [36] = { // GGML_TYPE_IQ4_NL_4_4
      .type_name                = "TYPE_IQ4_NL_4_4 REMOVED, use IQ4_NL with runtime repacking",
      .blck_size                = 0,
      .type_size                = 0,
      .is_quantized             = false0,
  },
  [37] = { // GGML_TYPE_IQ4_NL_4_8
      .type_name                = "TYPE_IQ4_NL_4_8 REMOVED, use IQ4_NL with runtime repacking",
      .blck_size                = 0,
      .type_size                = 0,
      .is_quantized             = false0,
  },
  [38] = { // GGML_TYPE_IQ4_NL_8_8
      .type_name                = "TYPE_IQ4_NL_8_8 REMOVED, use IQ4_NL with runtime repacking",
      .blck_size                = 0,
      .type_size                = 0,
      .is_quantized             = false0,
  },
930};

932const struct ggml_type_traits * ggml_get_type_traits(enum ggml_type type) {
  assert(type >= 0)((void) sizeof (__assert_single_arg (type >= 0)), __extension__
 ({ if (type >= 0) ; else __assert_fail ("type >= 0", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 933, __extension__ __PRETTY_FUNCTION__); }));
  assert(type < GGML_TYPE_COUNT)((void) sizeof (__assert_single_arg (type < GGML_TYPE_COUNT
)), __extension__ ({ if (type < GGML_TYPE_COUNT) ; else __assert_fail
 ("type < GGML_TYPE_COUNT", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 934, __extension__ __PRETTY_FUNCTION__); }));
  return &type_traits[type];
936}

938//
939// ggml object
940//

942struct ggml_object {
  size_t offs;
  size_t size;

  struct ggml_object * next;

  enum ggml_object_type type;

  char padding[4];
951};

953static const size_t GGML_OBJECT_SIZE = sizeof(struct ggml_object);

955//
956// ggml context
957//

959struct ggml_context {
  size_t mem_size;
  void * mem_buffer;
  bool_Bool   mem_buffer_owned;
  bool_Bool   no_alloc;

  int    n_objects;

  struct ggml_object * objects_begin;
  struct ggml_object * objects_end;
969};

971//
972// data types
973//

975static const char * GGML_OP_NAME[GGML_OP_COUNT] = {
  "NONE",

  "DUP",
  "ADD",
  "ADD_ID",
  "ADD1",
  "ACC",
  "SUB",
  "MUL",
  "DIV",
  "SQR",
  "SQRT",
  "LOG",
  "SIN",
  "COS",
  "SUM",
  "SUM_ROWS",
  "CUMSUM",
  "MEAN",
  "ARGMAX",
  "COUNT_EQUAL",
  "REPEAT",
  "REPEAT_BACK",
  "CONCAT",
  "SILU_BACK",
  "NORM",
  "RMS_NORM",
  "RMS_NORM_BACK",
  "GROUP_NORM",
  "L2_NORM",

  "MUL_MAT",
  "MUL_MAT_ID",
  "OUT_PROD",

  "SCALE",
  "SET",
  "CPY",
  "CONT",
  "RESHAPE",
  "VIEW",
  "PERMUTE",
  "TRANSPOSE",
  "GET_ROWS",
  "GET_ROWS_BACK",
  "SET_ROWS",
  "DIAG",
  "DIAG_MASK_INF",
  "DIAG_MASK_ZERO",
  "SOFT_MAX",
  "SOFT_MAX_BACK",
  "ROPE",
  "ROPE_BACK",
  "CLAMP",
  "CONV_TRANSPOSE_1D",
  "IM2COL",
  "IM2COL_BACK",
  "IM2COL_3D",
  "COL2IM_1D",
  "CONV_2D",
  "CONV_3D",
  "CONV_2D_DW",
  "CONV_TRANSPOSE_2D",
  "POOL_1D",
  "POOL_2D",
  "POOL_2D_BACK",
  "UPSCALE",
  "PAD",
  "PAD_REFLECT_1D",
  "ROLL",
  "ARANGE",
  "TIMESTEP_EMBEDDING",
  "ARGSORT",
  "TOP_K",
  "LEAKY_RELU",
  "TRI",
  "FILL",

  "FLASH_ATTN_EXT",
  "FLASH_ATTN_BACK",
  "SSM_CONV",
  "SSM_SCAN",
  "WIN_PART",
  "WIN_UNPART",
  "GET_REL_POS",
  "ADD_REL_POS",
  "RWKV_WKV6",
  "GATED_LINEAR_ATTN",
  "RWKV_WKV7",
  "SOLVE_TRI",
  "GATED_DELTA_NET",

  "UNARY",

  "MAP_CUSTOM1",
  "MAP_CUSTOM2",
  "MAP_CUSTOM3",

  "CUSTOM",

  "CROSS_ENTROPY_LOSS",
  "CROSS_ENTROPY_LOSS_BACK",
  "OPT_STEP_ADAMW",
  "OPT_STEP_SGD",

  "GLU",
1082};

1084static_assert_Static_assert(GGML_OP_COUNT == 97, "GGML_OP_COUNT != 97");

1086static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = {
  "none",

  "x",
  "x+y",
  "x[i]+y",
  "x+y",
  "view(x,nb,offset)+=y->x",
  "x-y",
  "x*y",
  "x/y",
  "x^2",
  "√x",
  "log(x)",
  "sin(x)",
  "cos(x)",
  "Σx",
  "Σx_k",
  "cumsum(x)",
  "Σx/n",
  "argmax(x)",
  "count_equal(x)",
  "repeat(x)",
  "repeat_back(x)",
  "concat(x, y)",
  "silu_back(x)",
  "norm(x)",
  "rms_norm(x)",
  "rms_norm_back(x)",
  "group_norm(x)",
  "l2_norm(x)",

  "X*Y",
  "X[i]*Y",
  "X*Y",

  "x*v",
  "y-\\>view(x)",
  "x-\\>y",
  "cont(x)",
  "reshape(x)",
  "view(x)",
  "permute(x)",
  "transpose(x)",
  "get_rows(x)",
  "get_rows_back(x)",
  "set_rows(x)",
  "diag(x)",
  "diag_mask_inf(x)",
  "diag_mask_zero(x)",
  "soft_max(x)",
  "soft_max_back(x)",
  "rope(x)",
  "rope_back(x)",
  "clamp(x)",
  "conv_transpose_1d(x)",
  "im2col(x)",
  "im2col_back(x)",
  "im2col_3d(x)",
  "col2im_1d(x)",
  "conv_2d(x)",
  "conv_3d(x)",
  "conv_2d_dw(x)",
  "conv_transpose_2d(x)",
  "pool_1d(x)",
  "pool_2d(x)",
  "pool_2d_back(x)",
  "upscale(x)",
  "pad(x)",
  "pad_reflect_1d(x)",
  "roll(x)",
  "arange(start, stop, step)",
  "timestep_embedding(timesteps, dim, max_period)",
  "argsort(x)",
  "top_k(x)",
  "leaky_relu(x)",
  "tri(x)",
  "fill(x, c)",

  "flash_attn_ext(x)",
  "flash_attn_back(x)",
  "ssm_conv(x)",
  "ssm_scan(x)",
  "win_part(x)",
  "win_unpart(x)",
  "get_rel_pos(x)",
  "add_rel_pos(x)",
  "rwkv_wkv6(k, v, r, tf, td, s)",
  "gated_linear_attn(k, v, q, gate, s)",
  "rwkv_wkv7(r, w, k, v, a, b, s)",
  "A X = B, A triangular, solve X",
  "gated_delta_net(q, k, v, g, beta, s)",

  "unary(x)",

  "map_custom(x)",
  "map_custom(x,y)",
  "map_custom(x,y,z)",

  "custom(x)",

  "cross_entropy_loss(x,y)",
  "cross_entropy_loss_back(x,y)",
  "adamw(x)",
  "sgd(x)",

  "glu(x)",
1193};

1195static_assert_Static_assert(GGML_OP_COUNT == 97, "GGML_OP_COUNT != 97");

1197static_assert_Static_assert(GGML_OP_POOL_COUNT == 2, "GGML_OP_POOL_COUNT != 2");

1199static const char * GGML_UNARY_OP_NAME[GGML_UNARY_OP_COUNT] = {
  "ABS",
  "SGN",
  "NEG",
  "STEP",
  "TANH",
  "ELU",
  "RELU",
  "SIGMOID",
  "GELU",
  "GELU_QUICK",
  "SILU",
  "HARDSWISH",
  "HARDSIGMOID",
  "EXP",
  "EXPM1",
  "SOFTPLUS",
  "GELU_ERF",
  "XIELU",
  "FLOOR",
  "CEIL",
  "ROUND",
  "TRUNC",
1222};

1224static_assert_Static_assert(GGML_UNARY_OP_COUNT == 22, "GGML_UNARY_OP_COUNT != 22");

1226static const char * GGML_GLU_OP_NAME[GGML_GLU_OP_COUNT] = {
  "REGLU",
  "GEGLU",
  "SWIGLU",
  "SWIGLU_OAI",
  "GEGLU_ERF",
  "GEGLU_QUICK",
1233};

1235static_assert_Static_assert(GGML_GLU_OP_COUNT == 6, "GGML_GLU_OP_COUNT != 6");


1238static_assert_Static_assert(sizeof(struct ggml_object)%GGML_MEM_ALIGN16 == 0, "ggml_object size must be a multiple of GGML_MEM_ALIGN");
1239static_assert_Static_assert(sizeof(struct ggml_tensor)%GGML_MEM_ALIGN16 == 0, "ggml_tensor size must be a multiple of GGML_MEM_ALIGN");


1242////////////////////////////////////////////////////////////////////////////////

1244void ggml_print_object(const struct ggml_object * obj) {
  GGML_LOG_INFO(" - ggml_object: type = %d, offset = %zu, size = %zu, next = %p\n",ggml_log_internal(GGML_LOG_LEVEL_INFO , " - ggml_object: type = %d, offset = %zu, size = %zu, next = %p\n"
, obj->type, obj->offs, obj->size, (const void *) obj
->next)
          obj->type, obj->offs, obj->size, (const void *) obj->next)ggml_log_internal(GGML_LOG_LEVEL_INFO , " - ggml_object: type = %d, offset = %zu, size = %zu, next = %p\n"
, obj->type, obj->offs, obj->size, (const void *) obj
->next);
1247}

1249void ggml_print_objects(const struct ggml_context * ctx) {
  struct ggml_object * obj = ctx->objects_begin;

  GGML_LOG_INFO("%s: objects in context %p:\n", __func__, (const void *) ctx)ggml_log_internal(GGML_LOG_LEVEL_INFO , "%s: objects in context %p:\n"
, __func__, (const void *) ctx);

  while (obj != NULL((void*)0)) {
      ggml_print_object(obj);
      obj = obj->next;
  }

  GGML_LOG_INFO("%s: --- end ---\n", __func__)ggml_log_internal(GGML_LOG_LEVEL_INFO , "%s: --- end ---\n", __func__
);
1260}

1262int64_t ggml_nelements(const struct ggml_tensor * tensor) {
  static_assert_Static_assert(GGML_MAX_DIMS4 == 4, "GGML_MAX_DIMS is not 4 - update this function");

  return tensor->ne[0]*tensor->ne[1]*tensor->ne[2]*tensor->ne[3];
1266}

1268int64_t ggml_nrows(const struct ggml_tensor * tensor) {
  static_assert_Static_assert(GGML_MAX_DIMS4 == 4, "GGML_MAX_DIMS is not 4 - update this function");

  return tensor->ne[1]*tensor->ne[2]*tensor->ne[3];
1272}

1274size_t ggml_nbytes(const struct ggml_tensor * tensor) {
  for (int i = 0; i < GGML_MAX_DIMS4; ++i) {
      if (tensor->ne[i] <= 0) {
          return 0;
      }
  }

  size_t nbytes;
  const size_t blck_size = ggml_blck_size(tensor->type);
  if (blck_size == 1) {
      nbytes = ggml_type_size(tensor->type);
      for (int i = 0; i < GGML_MAX_DIMS4; ++i) {
          nbytes += (tensor->ne[i] - 1)*tensor->nb[i];
      }
  }
  else {
      nbytes = tensor->ne[0]*tensor->nb[0]/blck_size;
      for (int i = 1; i < GGML_MAX_DIMS4; ++i) {
          nbytes += (tensor->ne[i] - 1)*tensor->nb[i];
      }
  }

  return nbytes;
1297}

1299size_t ggml_nbytes_pad(const struct ggml_tensor * tensor) {
  return GGML_PAD(ggml_nbytes(tensor), GGML_MEM_ALIGN)(((ggml_nbytes(tensor)) + (16) - 1) & ~((16) - 1));
1301}

1303int64_t ggml_blck_size(enum ggml_type type) {
  assert(type >= 0)((void) sizeof (__assert_single_arg (type >= 0)), __extension__
 ({ if (type >= 0) ; else __assert_fail ("type >= 0", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1304, __extension__ __PRETTY_FUNCTION__); }));
  assert(type < GGML_TYPE_COUNT)((void) sizeof (__assert_single_arg (type < GGML_TYPE_COUNT
)), __extension__ ({ if (type < GGML_TYPE_COUNT) ; else __assert_fail
 ("type < GGML_TYPE_COUNT", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1305, __extension__ __PRETTY_FUNCTION__); }));
  return type_traits[type].blck_size;
1307}

1309size_t ggml_type_size(enum ggml_type type) {
  assert(type >= 0)((void) sizeof (__assert_single_arg (type >= 0)), __extension__
 ({ if (type >= 0) ; else __assert_fail ("type >= 0", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1310, __extension__ __PRETTY_FUNCTION__); }));
  assert(type < GGML_TYPE_COUNT)((void) sizeof (__assert_single_arg (type < GGML_TYPE_COUNT
)), __extension__ ({ if (type < GGML_TYPE_COUNT) ; else __assert_fail
 ("type < GGML_TYPE_COUNT", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1311, __extension__ __PRETTY_FUNCTION__); }));
  return type_traits[type].type_size;
1313}

1315size_t ggml_row_size(enum ggml_type type, int64_t ne) {
  assert(type >= 0)((void) sizeof (__assert_single_arg (type >= 0)), __extension__
 ({ if (type >= 0) ; else __assert_fail ("type >= 0", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1316, __extension__ __PRETTY_FUNCTION__); }));
  assert(type < GGML_TYPE_COUNT)((void) sizeof (__assert_single_arg (type < GGML_TYPE_COUNT
)), __extension__ ({ if (type < GGML_TYPE_COUNT) ; else __assert_fail
 ("type < GGML_TYPE_COUNT", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1317, __extension__ __PRETTY_FUNCTION__); }));
  assert(ne % ggml_blck_size(type) == 0)((void) sizeof (__assert_single_arg (ne % ggml_blck_size(type
) == 0)), __extension__ ({ if (ne % ggml_blck_size(type) == 0
) ; else __assert_fail ("ne % ggml_blck_size(type) == 0", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1318, __extension__ __PRETTY_FUNCTION__); }));
  return ggml_type_size(type)*ne/ggml_blck_size(type);
1320}

1322double ggml_type_sizef(enum ggml_type type) {
  assert(type >= 0)((void) sizeof (__assert_single_arg (type >= 0)), __extension__
 ({ if (type >= 0) ; else __assert_fail ("type >= 0", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1323, __extension__ __PRETTY_FUNCTION__); }));
  assert(type < GGML_TYPE_COUNT)((void) sizeof (__assert_single_arg (type < GGML_TYPE_COUNT
)), __extension__ ({ if (type < GGML_TYPE_COUNT) ; else __assert_fail
 ("type < GGML_TYPE_COUNT", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1324, __extension__ __PRETTY_FUNCTION__); }));
  return ((double)(type_traits[type].type_size))/type_traits[type].blck_size;
1326}

1328const char * ggml_type_name(enum ggml_type type) {
  assert(type >= 0)((void) sizeof (__assert_single_arg (type >= 0)), __extension__
 ({ if (type >= 0) ; else __assert_fail ("type >= 0", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1329, __extension__ __PRETTY_FUNCTION__); }));
  assert(type < GGML_TYPE_COUNT)((void) sizeof (__assert_single_arg (type < GGML_TYPE_COUNT
)), __extension__ ({ if (type < GGML_TYPE_COUNT) ; else __assert_fail
 ("type < GGML_TYPE_COUNT", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1330, __extension__ __PRETTY_FUNCTION__); }));
  return type_traits[type].type_name;
1332}

1334bool_Bool ggml_is_quantized(enum ggml_type type) {
  assert(type >= 0)((void) sizeof (__assert_single_arg (type >= 0)), __extension__
 ({ if (type >= 0) ; else __assert_fail ("type >= 0", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1335, __extension__ __PRETTY_FUNCTION__); }));
  assert(type < GGML_TYPE_COUNT)((void) sizeof (__assert_single_arg (type < GGML_TYPE_COUNT
)), __extension__ ({ if (type < GGML_TYPE_COUNT) ; else __assert_fail
 ("type < GGML_TYPE_COUNT", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1336, __extension__ __PRETTY_FUNCTION__); }));
  return type_traits[type].is_quantized;
1338}

1340const char * ggml_op_name(enum ggml_op op) {
  return GGML_OP_NAME[op];
1342}

1344const char * ggml_op_symbol(enum ggml_op op) {
  return GGML_OP_SYMBOL[op];
1346}

1348const char * ggml_unary_op_name(enum ggml_unary_op op) {
  return GGML_UNARY_OP_NAME[op];
1350}

1352const char * ggml_glu_op_name(enum ggml_glu_op op) {
  return GGML_GLU_OP_NAME[op];
1354}

1356const char * ggml_op_desc(const struct ggml_tensor * t) {
  if (t->op == GGML_OP_UNARY) {
      enum ggml_unary_op uop = ggml_get_unary_op(t);
      return ggml_unary_op_name(uop);
  }
  if (t->op == GGML_OP_GLU) {
      enum ggml_glu_op gop = ggml_get_glu_op(t);
      return ggml_glu_op_name(gop);
  }
  return ggml_op_name(t->op);
1366}

1368size_t ggml_element_size(const struct ggml_tensor * tensor) {
  return ggml_type_size(tensor->type);
1370}

1372bool_Bool ggml_is_scalar(const struct ggml_tensor * tensor) {
  static_assert_Static_assert(GGML_MAX_DIMS4 == 4, "GGML_MAX_DIMS is not 4 - update this function");

  return tensor->ne[0] == 1 && tensor->ne[1] == 1 && tensor->ne[2] == 1 && tensor->ne[3] == 1;
1376}

1378bool_Bool ggml_is_vector(const struct ggml_tensor * tensor) {
  static_assert_Static_assert(GGML_MAX_DIMS4 == 4, "GGML_MAX_DIMS is not 4 - update this function");

  return tensor->ne[1] == 1 && tensor->ne[2] == 1 && tensor->ne[3] == 1;
1382}

1384bool_Bool ggml_is_matrix(const struct ggml_tensor * tensor) {
  static_assert_Static_assert(GGML_MAX_DIMS4 == 4, "GGML_MAX_DIMS is not 4 - update this function");

  return tensor->ne[2] == 1 && tensor->ne[3] == 1;
1388}

1390bool_Bool ggml_is_3d(const struct ggml_tensor * tensor) {
  return tensor->ne[3] == 1;
1392}

1394int ggml_n_dims(const struct ggml_tensor * tensor) {
  for (int i = GGML_MAX_DIMS4 - 1; i >= 1; --i) {
      if (tensor->ne[i] > 1) {
          return i + 1;
      }
  }
  return 1;
1401}

1403enum ggml_type ggml_ftype_to_ggml_type(enum ggml_ftype ftype) {
  enum ggml_type wtype = GGML_TYPE_COUNT;

  switch (ftype) {
      case GGML_FTYPE_ALL_F32:              wtype = GGML_TYPE_F32;   break;
      case GGML_FTYPE_MOSTLY_F16:           wtype = GGML_TYPE_F16;   break;
      case GGML_FTYPE_MOSTLY_BF16:          wtype = GGML_TYPE_BF16;  break;
      case GGML_FTYPE_MOSTLY_Q4_0:          wtype = GGML_TYPE_Q4_0;  break;
      case GGML_FTYPE_MOSTLY_Q4_1:          wtype = GGML_TYPE_Q4_1;  break;
      case GGML_FTYPE_MOSTLY_Q1_0:          wtype = GGML_TYPE_Q1_0;  break;
      case GGML_FTYPE_MOSTLY_Q5_0:          wtype = GGML_TYPE_Q5_0;  break;
      case GGML_FTYPE_MOSTLY_Q5_1:          wtype = GGML_TYPE_Q5_1;  break;
      case GGML_FTYPE_MOSTLY_Q8_0:          wtype = GGML_TYPE_Q8_0;  break;
      case GGML_FTYPE_MOSTLY_MXFP4:         wtype = GGML_TYPE_MXFP4; break;
      case GGML_FTYPE_MOSTLY_NVFP4:         wtype = GGML_TYPE_NVFP4; break;
      case GGML_FTYPE_MOSTLY_Q2_K:          wtype = GGML_TYPE_Q2_K;  break;
      case GGML_FTYPE_MOSTLY_Q3_K:          wtype = GGML_TYPE_Q3_K;  break;
      case GGML_FTYPE_MOSTLY_Q4_K:          wtype = GGML_TYPE_Q4_K;  break;
      case GGML_FTYPE_MOSTLY_Q5_K:          wtype = GGML_TYPE_Q5_K;  break;
      case GGML_FTYPE_MOSTLY_Q6_K:          wtype = GGML_TYPE_Q6_K;  break;
      case GGML_FTYPE_MOSTLY_IQ2_XXS:       wtype = GGML_TYPE_IQ2_XXS;  break;
      case GGML_FTYPE_MOSTLY_IQ2_XS:        wtype = GGML_TYPE_IQ2_XS;   break;
      case GGML_FTYPE_MOSTLY_IQ3_XXS:       wtype = GGML_TYPE_IQ3_XXS;  break;
      case GGML_FTYPE_MOSTLY_IQ1_S:         wtype = GGML_TYPE_IQ1_S;    break;
      case GGML_FTYPE_MOSTLY_IQ1_M:         wtype = GGML_TYPE_IQ1_M;    break;
      case GGML_FTYPE_MOSTLY_IQ4_NL:        wtype = GGML_TYPE_IQ4_NL;   break;
      case GGML_FTYPE_MOSTLY_IQ4_XS:        wtype = GGML_TYPE_IQ4_XS;   break;
      case GGML_FTYPE_MOSTLY_IQ3_S:         wtype = GGML_TYPE_IQ3_S;    break;
      case GGML_FTYPE_MOSTLY_IQ2_S:         wtype = GGML_TYPE_IQ2_S;    break;
      case GGML_FTYPE_UNKNOWN:              wtype = GGML_TYPE_COUNT; break;
      case GGML_FTYPE_MOSTLY_Q4_1_SOME_F16: wtype = GGML_TYPE_COUNT; break;
  }

  GGML_ASSERT(wtype != GGML_TYPE_COUNT)if (!(wtype != GGML_TYPE_COUNT)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1436, "GGML_ASSERT(%s) failed", "wtype != GGML_TYPE_COUNT");

  return wtype;
1439}

1441size_t ggml_tensor_overhead(void) {
  return GGML_OBJECT_SIZE + GGML_TENSOR_SIZE;
1443}

1445bool_Bool ggml_is_transposed(const struct ggml_tensor * tensor) {
  return tensor->nb[0] > tensor->nb[1];
1447}

1449static bool_Bool ggml_is_contiguous_n(const struct ggml_tensor * tensor, int n) {
  size_t next_nb = ggml_type_size(tensor->type);
  if (tensor->ne[0] != ggml_blck_size(tensor->type) && tensor->nb[0] != next_nb) {
      return false0;
  }
  next_nb *= tensor->ne[0]/ggml_blck_size(tensor->type);
  for (int i = 1; i < GGML_MAX_DIMS4; i++) {
      if (i > n) {
          if (tensor->ne[i] != 1 && tensor->nb[i] != next_nb) {
              return false0;
          }
          next_nb *= tensor->ne[i];
      } else {
          // this dimension does not need to be contiguous
          next_nb = tensor->ne[i]*tensor->nb[i];
      }
  }
  return true1;
1467}

1469bool_Bool ggml_is_contiguous(const struct ggml_tensor * tensor) {
  return ggml_is_contiguous_0(tensor);
1471}

1473bool_Bool ggml_is_contiguous_0(const struct ggml_tensor * tensor) {
  return ggml_is_contiguous_n(tensor, 0);
1475}

1477bool_Bool ggml_is_contiguous_1(const struct ggml_tensor * tensor) {
  return ggml_is_contiguous_n(tensor, 1);
1479}

1481bool_Bool ggml_is_contiguous_2(const struct ggml_tensor * tensor) {
  return ggml_is_contiguous_n(tensor, 2);
1483}

1485bool_Bool ggml_is_contiguously_allocated(const struct ggml_tensor * tensor) {
  return ggml_nbytes(tensor) == ggml_nelements(tensor) * ggml_type_size(tensor->type)/ggml_blck_size(tensor->type);
1487}

1489bool_Bool ggml_is_permuted(const struct ggml_tensor * tensor) {
  static_assert_Static_assert(GGML_MAX_DIMS4 == 4, "GGML_MAX_DIMS is not 4 - update this function");

  return tensor->nb[0] > tensor->nb[1] || tensor->nb[1] > tensor->nb[2] || tensor->nb[2] > tensor->nb[3];
1493}

1495bool_Bool ggml_is_contiguous_channels(const struct ggml_tensor * tensor) {
  return
      tensor->nb[0] > tensor->nb[2] &&
      tensor->nb[1] > tensor->nb[0] &&
      tensor->nb[2] == ggml_type_size(tensor->type);
1500}

1502bool_Bool ggml_is_contiguous_rows(const struct ggml_tensor * tensor) {
  return
      tensor->ne[0] == ggml_blck_size(tensor->type) ||
      tensor->nb[0] == ggml_type_size(tensor->type);
1506}

1508static inline bool_Bool ggml_is_padded_1d(const struct ggml_tensor * tensor) {
  static_assert_Static_assert(GGML_MAX_DIMS4 == 4, "GGML_MAX_DIMS is not 4 - update this function");

  return
      tensor->nb[0] == ggml_type_size(tensor->type) &&
      tensor->nb[2] == tensor->nb[1]*tensor->ne[1] &&
      tensor->nb[3] == tensor->nb[2]*tensor->ne[2];
1515}

1517bool_Bool ggml_is_empty(const struct ggml_tensor * tensor) {
  for (int i = 0; i < GGML_MAX_DIMS4; ++i) {
      if (tensor->ne[i] == 0) {
          // empty if any dimension has no elements
          return true1;
      }
  }
  return false0;
1525}

1527bool_Bool ggml_are_same_shape(const struct ggml_tensor * t0, const struct ggml_tensor * t1) {
  static_assert_Static_assert(GGML_MAX_DIMS4 == 4, "GGML_MAX_DIMS is not 4 - update this function");

  return
      (t0->ne[0] == t1->ne[0]) &&
      (t0->ne[1] == t1->ne[1]) &&
      (t0->ne[2] == t1->ne[2]) &&
      (t0->ne[3] == t1->ne[3]);
1535}

1537bool_Bool ggml_are_same_stride(const struct ggml_tensor * t0, const struct ggml_tensor * t1) {
  static_assert_Static_assert(GGML_MAX_DIMS4 == 4, "GGML_MAX_DIMS is not 4 - update this function");

  return
      (t0->nb[0] == t1->nb[0]) &&
      (t0->nb[1] == t1->nb[1]) &&
      (t0->nb[2] == t1->nb[2]) &&
      (t0->nb[3] == t1->nb[3]);
1545}

1547bool_Bool ggml_is_view(const struct ggml_tensor * t) {
  return ggml_impl_is_view(t);
1549}

1551// check if t1 can be represented as a repetition of t0
1552bool_Bool ggml_can_repeat(const struct ggml_tensor * t0, const struct ggml_tensor * t1) {
  static_assert_Static_assert(GGML_MAX_DIMS4 == 4, "GGML_MAX_DIMS is not 4 - update this function");

  return ggml_is_empty(t0) ? ggml_is_empty(t1) :
      (t1->ne[0]%t0->ne[0] == 0) &&
      (t1->ne[1]%t0->ne[1] == 0) &&
      (t1->ne[2]%t0->ne[2] == 0) &&
      (t1->ne[3]%t0->ne[3] == 0);
1560}

1562static inline bool_Bool ggml_can_repeat_rows(const struct ggml_tensor * t0, const struct ggml_tensor * t1) {
  static_assert_Static_assert(GGML_MAX_DIMS4 == 4, "GGML_MAX_DIMS is not 4 - update this function");

  return (t0->ne[0] == t1->ne[0]) && ggml_can_repeat(t0, t1);
1566}

1568// assert that pointer is aligned to GGML_MEM_ALIGN
1569#define GGML_ASSERT_ALIGNED(ptr)if (!(((uintptr_t) (ptr))%16 == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1569, "GGML_ASSERT(%s) failed", "((uintptr_t) (ptr))%GGML_MEM_ALIGN == 0"
) \
  GGML_ASSERT(((uintptr_t) (ptr))%GGML_MEM_ALIGN == 0)if (!(((uintptr_t) (ptr))%16 == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1570, "GGML_ASSERT(%s) failed", "((uintptr_t) (ptr))%GGML_MEM_ALIGN == 0"
)

1572////////////////////////////////////////////////////////////////////////////////

1574struct ggml_context * ggml_init(struct ggml_init_params params) {
  static bool_Bool is_first_call = true1;

  ggml_critical_section_start();

  if (is_first_call) {
      // initialize time system (required on Windows)
      ggml_time_init();

      is_first_call = false0;
  }

  ggml_critical_section_end();

  struct ggml_context * ctx = GGML_MALLOC(sizeof(struct ggml_context))ggml_malloc(sizeof(struct ggml_context));

  // allow to call ggml_init with 0 size
  if (params.mem_size == 0) {
      params.mem_size = GGML_MEM_ALIGN16;
  }

  const size_t mem_size = params.mem_buffer ? params.mem_size : GGML_PAD(params.mem_size, GGML_MEM_ALIGN)(((params.mem_size) + (16) - 1) & ~((16) - 1));

  *ctx = (struct ggml_context) {
      /*.mem_size           =*/ mem_size,
      /*.mem_buffer         =*/ params.mem_buffer ? params.mem_buffer : ggml_aligned_malloc(mem_size),
      /*.mem_buffer_owned   =*/ params.mem_buffer ? false0 : true1,
      /*.no_alloc           =*/ params.no_alloc,
      /*.n_objects          =*/ 0,
      /*.objects_begin      =*/ NULL((void*)0),
      /*.objects_end        =*/ NULL((void*)0),
  };

  GGML_ASSERT(ctx->mem_buffer != NULL)if (!(ctx->mem_buffer != ((void*)0))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1607, "GGML_ASSERT(%s) failed", "ctx->mem_buffer != NULL"
);

  GGML_ASSERT_ALIGNED(ctx->mem_buffer)if (!(((uintptr_t) (ctx->mem_buffer))%16 == 0)) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1609, "GGML_ASSERT(%s) failed", "((uintptr_t) (ctx->mem_buffer))%GGML_MEM_ALIGN == 0"
);

  GGML_PRINT_DEBUG("%s: context initialized\n", __func__);

  return ctx;
1614}

1616void ggml_reset(struct ggml_context * ctx) {
  if (ctx == NULL((void*)0)) {
      return;
  }

  ctx->n_objects     = 0;
  ctx->objects_begin = NULL((void*)0);
  ctx->objects_end   = NULL((void*)0);
1624}

1626void ggml_free(struct ggml_context * ctx) {
  if (ctx == NULL((void*)0)) {
      return;
  }

  if (ctx->mem_buffer_owned) {
      ggml_aligned_free(ctx->mem_buffer, ctx->mem_size);
  }

  GGML_FREE(ctx)free(ctx);
1636}

1638size_t ggml_used_mem(const struct ggml_context * ctx) {
  return ctx->objects_end == NULL((void*)0) ? 0 : ctx->objects_end->offs + ctx->objects_end->size;
1640}

1642bool_Bool ggml_get_no_alloc(struct ggml_context * ctx) {
  return ctx->no_alloc;
1644}

1646void ggml_set_no_alloc(struct ggml_context * ctx, bool_Bool no_alloc) {
  ctx->no_alloc = no_alloc;
1648}

1650void * ggml_get_mem_buffer(const struct ggml_context * ctx) {
  return ctx->mem_buffer;
1652}

1654size_t ggml_get_mem_size(const struct ggml_context * ctx) {
  return ctx->mem_size;
1656}

1658size_t ggml_get_max_tensor_size(const struct ggml_context * ctx) {
  size_t max_size = 0;

  for (struct ggml_tensor * tensor = ggml_get_first_tensor(ctx); tensor != NULL((void*)0); tensor = ggml_get_next_tensor(ctx, tensor)) {
      size_t bytes = ggml_nbytes(tensor);
      max_size = MAX(max_size, bytes)((max_size) > (bytes) ? (max_size) : (bytes));
  }

  return max_size;
1667}

1669////////////////////////////////////////////////////////////////////////////////

1671static struct ggml_object * ggml_new_object(struct ggml_context * ctx, enum ggml_object_type type, size_t size) {
  // always insert objects at the end of the context's memory pool
  struct ggml_object * obj_cur = ctx->objects_end;

  const size_t cur_offs = obj_cur == NULL((void*)0) ? 0 : obj_cur->offs;
  const size_t cur_size = obj_cur == NULL((void*)0) ? 0 : obj_cur->size;
  const size_t cur_end  = cur_offs + cur_size;

  // align to GGML_MEM_ALIGN
  GGML_ASSERT(size <= SIZE_MAX - (GGML_MEM_ALIGN - 1))if (!(size <= (18446744073709551615UL) - (16 - 1))) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1680, "GGML_ASSERT(%s) failed", "size <= SIZE_MAX - (GGML_MEM_ALIGN - 1)"
);
  size_t size_needed = GGML_PAD(size, GGML_MEM_ALIGN)(((size) + (16) - 1) & ~((16) - 1));

  char * const mem_buffer = ctx->mem_buffer;
  struct ggml_object * const obj_new = (struct ggml_object *)(mem_buffer + cur_end);

  // integer overflow checks
  if (cur_end > SIZE_MAX(18446744073709551615UL) - size_needed) {
      GGML_LOG_WARN("%s: overflow detected in cur_end (%zu) + size_needed (%zu)\n", __func__, cur_end, size_needed)ggml_log_internal(GGML_LOG_LEVEL_WARN , "%s: overflow detected in cur_end (%zu) + size_needed (%zu)\n"
, __func__, cur_end, size_needed);
      return NULL((void*)0);
  }
  if (cur_end + size_needed > SIZE_MAX(18446744073709551615UL) - GGML_OBJECT_SIZE) {
      GGML_LOG_WARN("%s: overflow detected in cur_end (%zu) + size_needed (%zu) + GGML_OBJECT_SIZE (%zu)\n", __func__,ggml_log_internal(GGML_LOG_LEVEL_WARN , "%s: overflow detected in cur_end (%zu) + size_needed (%zu) + GGML_OBJECT_SIZE (%zu)\n"
, __func__, cur_end, size_needed, (size_t) GGML_OBJECT_SIZE)
              cur_end, size_needed, (size_t) GGML_OBJECT_SIZE)ggml_log_internal(GGML_LOG_LEVEL_WARN , "%s: overflow detected in cur_end (%zu) + size_needed (%zu) + GGML_OBJECT_SIZE (%zu)\n"
, __func__, cur_end, size_needed, (size_t) GGML_OBJECT_SIZE);
      return NULL((void*)0);
  }

  if (cur_end + size_needed + GGML_OBJECT_SIZE > ctx->mem_size) {
      GGML_LOG_WARN("%s: not enough space in the context's memory pool (needed %zu, available %zu)\n",ggml_log_internal(GGML_LOG_LEVEL_WARN , "%s: not enough space in the context's memory pool (needed %zu, available %zu)\n"
, __func__, cur_end + size_needed + GGML_OBJECT_SIZE, ctx->
mem_size)
              __func__, cur_end + size_needed + GGML_OBJECT_SIZE, ctx->mem_size)ggml_log_internal(GGML_LOG_LEVEL_WARN , "%s: not enough space in the context's memory pool (needed %zu, available %zu)\n"
, __func__, cur_end + size_needed + GGML_OBJECT_SIZE, ctx->
mem_size);
1700#ifndef NDEBUG
      GGML_ABORT("not enough space in the context's memory pool")ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1701, "not enough space in the context's memory pool");
1702#endif
      return NULL((void*)0);
  }

  *obj_new = (struct ggml_object) {
      .offs = cur_end + GGML_OBJECT_SIZE,
      .size = size_needed,
      .next = NULL((void*)0),
      .type = type,
  };

  GGML_ASSERT_ALIGNED(mem_buffer + obj_new->offs)if (!(((uintptr_t) (mem_buffer + obj_new->offs))%16 == 0))
 ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1713, "GGML_ASSERT(%s) failed", "((uintptr_t) (mem_buffer + obj_new->offs))%GGML_MEM_ALIGN == 0"
);

  if (obj_cur != NULL((void*)0)) {
      obj_cur->next = obj_new;
  } else {
      // this is the first object in this context
      ctx->objects_begin = obj_new;
  }

  ctx->objects_end = obj_new;

  //printf("%s: inserted new object at %zu, size = %zu\n", __func__, cur_end, obj_new->size);

  return obj_new;
1727}

1729static struct ggml_tensor * ggml_new_tensor_impl(
      struct ggml_context * ctx,
      enum   ggml_type      type,
      int                   n_dims,
      const int64_t       * ne,
      struct ggml_tensor  * view_src,
      size_t                view_offs) {

  GGML_ASSERT(type >= 0 && type < GGML_TYPE_COUNT)if (!(type >= 0 && type < GGML_TYPE_COUNT)) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1737, "GGML_ASSERT(%s) failed", "type >= 0 && type < GGML_TYPE_COUNT"
);
  GGML_ASSERT(n_dims >= 1 && n_dims <= GGML_MAX_DIMS)if (!(n_dims >= 1 && n_dims <= 4)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1738, "GGML_ASSERT(%s) failed", "n_dims >= 1 && n_dims <= GGML_MAX_DIMS"
);

  // find the base tensor and absolute offset
  if (view_src != NULL((void*)0) && view_src->view_src != NULL((void*)0)) {
      view_offs += view_src->view_offs;
      view_src   = view_src->view_src;
  }

  size_t data_size = ggml_row_size(type, ne[0]);
  for (int i = 1; i < n_dims; i++) {
      data_size *= ne[i];
  }

  GGML_ASSERT(view_src == NULL || data_size == 0 || data_size + view_offs <= ggml_nbytes(view_src))if (!(view_src == ((void*)0) || data_size == 0 || data_size +
 view_offs <= ggml_nbytes(view_src))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1751, "GGML_ASSERT(%s) failed", "view_src == NULL || data_size == 0 || data_size + view_offs <= ggml_nbytes(view_src)"
);

  void * data = view_src != NULL((void*)0) ? view_src->data : NULL((void*)0);
  if (data != NULL((void*)0)) {
      data = (char *) data + view_offs;
  }

  size_t obj_alloc_size = 0;

  if (view_src == NULL((void*)0) && !ctx->no_alloc) {
      // allocate tensor data in the context's memory pool
      obj_alloc_size = data_size;
  }

  GGML_ASSERT(GGML_TENSOR_SIZE <= SIZE_MAX - obj_alloc_size)if (!(GGML_TENSOR_SIZE <= (18446744073709551615UL) - obj_alloc_size
)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1765, "GGML_ASSERT(%s) failed", "GGML_TENSOR_SIZE <= SIZE_MAX - obj_alloc_size"
);

  struct ggml_object * const obj_new = ggml_new_object(ctx, GGML_OBJECT_TYPE_TENSOR, GGML_TENSOR_SIZE + obj_alloc_size);
  GGML_ASSERT(obj_new)if (!(obj_new)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1768, "GGML_ASSERT(%s) failed", "obj_new");

  struct ggml_tensor * const result = (struct ggml_tensor *)((char *)ctx->mem_buffer + obj_new->offs);

  *result = (struct ggml_tensor) {
      /*.type         =*/ type,
      /*.buffer       =*/ NULL((void*)0),
      /*.ne           =*/ { 1, 1, 1, 1 },
      /*.nb           =*/ { 0, 0, 0, 0 },
      /*.op           =*/ GGML_OP_NONE,
      /*.op_params    =*/ { 0 },
      /*.flags        =*/ 0,
      /*.src          =*/ { NULL((void*)0) },
      /*.view_src     =*/ view_src,
      /*.view_offs    =*/ view_offs,
      /*.data         =*/ obj_alloc_size > 0 ? (void *)(result + 1) : data,
      /*.name         =*/ { 0 },
      /*.extra        =*/ NULL((void*)0),
      /*.padding      =*/ { 0 },
  };

  // TODO: this should not be needed as long as we don't rely on aligned SIMD loads
  //GGML_ASSERT_ALIGNED(result->data);

  for (int i = 0; i < n_dims; i++) {
      result->ne[i] = ne[i];
  }

  result->nb[0] = ggml_type_size(type);
  result->nb[1] = result->nb[0]*(result->ne[0]/ggml_blck_size(type));
  for (int i = 2; i < GGML_MAX_DIMS4; i++) {
      result->nb[i] = result->nb[i - 1]*result->ne[i - 1];
  }

  ctx->n_objects++;

  return result;
1805}

1807struct ggml_tensor * ggml_new_tensor(
      struct ggml_context * ctx,
      enum   ggml_type      type,
      int                   n_dims,
      const int64_t       * ne) {
  return ggml_new_tensor_impl(ctx, type, n_dims, ne, NULL((void*)0), 0);
1813}

1815struct ggml_tensor * ggml_new_tensor_1d(
      struct ggml_context * ctx,
      enum   ggml_type      type,
      int64_t ne0) {
  return ggml_new_tensor(ctx, type, 1, &ne0);
1820}

1822struct ggml_tensor * ggml_new_tensor_2d(
      struct ggml_context * ctx,
      enum   ggml_type      type,
      int64_t ne0,
      int64_t ne1) {
  const int64_t ne[2] = { ne0, ne1 };
  return ggml_new_tensor(ctx, type, 2, ne);
1829}

1831struct ggml_tensor * ggml_new_tensor_3d(
      struct ggml_context * ctx,
      enum   ggml_type      type,
      int64_t ne0,
      int64_t ne1,
      int64_t ne2) {
  const int64_t ne[3] = { ne0, ne1, ne2 };
  return ggml_new_tensor(ctx, type, 3, ne);
1839}

1841struct ggml_tensor * ggml_new_tensor_4d(
      struct ggml_context * ctx,
      enum   ggml_type type,
      int64_t ne0,
      int64_t ne1,
      int64_t ne2,
      int64_t ne3) {
  const int64_t ne[4] = { ne0, ne1, ne2, ne3 };
  return ggml_new_tensor(ctx, type, 4, ne);
1850}

1852void * ggml_new_buffer(struct ggml_context * ctx, size_t nbytes) {
  struct ggml_object * obj = ggml_new_object(ctx, GGML_OBJECT_TYPE_WORK_BUFFER, nbytes);

  return (uint8_t *)ctx->mem_buffer + obj->offs;
1856}

1858struct ggml_tensor * ggml_dup_tensor(struct ggml_context * ctx, const struct ggml_tensor * src) {
  return ggml_new_tensor(ctx, src->type, GGML_MAX_DIMS4, src->ne);
25
←
Access to field 'type' results in a dereference of a null pointer (loaded from variable 'src')
1860}

1862void ggml_unravel_index(const struct ggml_tensor * tensor, int64_t i, int64_t * i0, int64_t * i1, int64_t * i2, int64_t * i3) {
  const int64_t ne2 = tensor->ne[2];
  const int64_t ne1 = tensor->ne[1];
  const int64_t ne0 = tensor->ne[0];

  const int64_t i3_ = (i/(ne2*ne1*ne0));
  const int64_t i2_ = (i - i3_*ne2*ne1*ne0)/(ne1*ne0);
  const int64_t i1_ = (i - i3_*ne2*ne1*ne0 - i2_*ne1*ne0)/ne0;
  const int64_t i0_ = (i - i3_*ne2*ne1*ne0 - i2_*ne1*ne0 - i1_*ne0);

  if (i0) {
      * i0 = i0_;
  }
  if (i1) {
      * i1 = i1_;
  }
  if (i2) {
      * i2 = i2_;
  }
  if (i3) {
      * i3 = i3_;
  }
1884}

1886void * ggml_get_data(const struct ggml_tensor * tensor) {
  return tensor->data;
1888}

1890float * ggml_get_data_f32(const struct ggml_tensor * tensor) {
  assert(tensor->type == GGML_TYPE_F32)((void) sizeof (__assert_single_arg (tensor->type == GGML_TYPE_F32
)), __extension__ ({ if (tensor->type == GGML_TYPE_F32) ; else
 __assert_fail ("tensor->type == GGML_TYPE_F32", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1891, __extension__ __PRETTY_FUNCTION__); }));
  return (float *)(tensor->data);
1893}

1895enum ggml_unary_op ggml_get_unary_op(const struct ggml_tensor * tensor) {
  GGML_ASSERT(tensor->op == GGML_OP_UNARY)if (!(tensor->op == GGML_OP_UNARY)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1896, "GGML_ASSERT(%s) failed", "tensor->op == GGML_OP_UNARY"
);
  return (enum ggml_unary_op) ggml_get_op_params_i32(tensor, 0);
1898}

1900enum ggml_glu_op ggml_get_glu_op(const struct ggml_tensor * tensor) {
  GGML_ASSERT(tensor->op == GGML_OP_GLU)if (!(tensor->op == GGML_OP_GLU)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 1901, "GGML_ASSERT(%s) failed", "tensor->op == GGML_OP_GLU"
);
  return (enum ggml_glu_op) ggml_get_op_params_i32(tensor, 0);
1903}

1905const char * ggml_get_name(const struct ggml_tensor * tensor) {
  return tensor->name;
1907}

1909struct ggml_tensor * ggml_set_name(struct ggml_tensor * tensor, const char * name) {
  size_t i;
  for (i = 0; i < sizeof(tensor->name) - 1 && name[i] != '\0'; i++) {
      tensor->name[i] = name[i];
  }
  tensor->name[i] = '\0';
  return tensor;
1916}

1918struct ggml_tensor * ggml_format_name(struct ggml_tensor * tensor, const char * fmt, ...) {
  va_list args;
  va_start(args, fmt)__builtin_va_start(args, fmt);
  vsnprintf(tensor->name, sizeof(tensor->name), fmt, args);
  va_end(args)__builtin_va_end(args);
  return tensor;
1924}

1926struct ggml_tensor * ggml_view_tensor(
      struct ggml_context * ctx,
      struct ggml_tensor  * src) {
  struct ggml_tensor * result = ggml_new_tensor_impl(ctx, src->type, GGML_MAX_DIMS4, src->ne, src, 0);
  ggml_format_name(result, "%s (view)", src->name);

  for (int i = 0; i < GGML_MAX_DIMS4; i++) {
      result->nb[i] = src->nb[i];
  }

  return result;
1937}

1939struct ggml_tensor * ggml_get_first_tensor(const struct ggml_context * ctx) {
  struct ggml_object * obj = ctx->objects_begin;

  char * const mem_buffer = ctx->mem_buffer;

  while (obj != NULL((void*)0)) {
      if (obj->type == GGML_OBJECT_TYPE_TENSOR) {
          return (struct ggml_tensor *)(mem_buffer + obj->offs);
      }

      obj = obj->next;
  }

  return NULL((void*)0);
1953}

1955struct ggml_tensor * ggml_get_next_tensor(const struct ggml_context * ctx, struct ggml_tensor * tensor) {
  struct ggml_object * obj = (struct ggml_object *) ((char *)tensor - GGML_OBJECT_SIZE);
  obj = obj->next;

  char * const mem_buffer = ctx->mem_buffer;

  while (obj != NULL((void*)0)) {
      if (obj->type == GGML_OBJECT_TYPE_TENSOR) {
          return (struct ggml_tensor *)(mem_buffer + obj->offs);
      }

      obj = obj->next;
  }

  return NULL((void*)0);
1970}

1972struct ggml_tensor * ggml_get_tensor(struct ggml_context * ctx, const char * name) {
  struct ggml_object * obj = ctx->objects_begin;

  char * const mem_buffer = ctx->mem_buffer;

  while (obj != NULL((void*)0)) {
      if (obj->type == GGML_OBJECT_TYPE_TENSOR) {
          struct ggml_tensor * cur = (struct ggml_tensor *)(mem_buffer + obj->offs);
          if (strcmp(cur->name, name) == 0) {
              return cur;
          }
      }

      obj = obj->next;
  }

  return NULL((void*)0);
1989}

1991////////////////////////////////////////////////////////////////////////////////

1993// ggml_dup

1995static struct ggml_tensor * ggml_dup_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      bool_Bool                  inplace) {
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  result->op     = GGML_OP_DUP;
  result->src[0] = a;

  return result;
2005}

2007struct ggml_tensor * ggml_dup(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_dup_impl(ctx, a, false0);
2011}

2013struct ggml_tensor * ggml_dup_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_dup_impl(ctx, a, true1);
2017}

2019// ggml_add

2021static struct ggml_tensor * ggml_add_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      bool_Bool                  inplace) {
  GGML_ASSERT(ggml_can_repeat(b, a))if (!(ggml_can_repeat(b, a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2026, "GGML_ASSERT(%s) failed", "ggml_can_repeat(b, a)");

  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  result->op     = GGML_OP_ADD;
  result->src[0] = a;
  result->src[1] = b;

  return result;
2035}

2037struct ggml_tensor * ggml_add(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_add_impl(ctx, a, b, false0);
2042}

2044struct ggml_tensor * ggml_add_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_add_impl(ctx, a, b, true1);
2049}

2051// ggml_add_cast

2053static struct ggml_tensor * ggml_add_cast_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      enum   ggml_type      type) {
  // TODO: support less-strict constraint
  //       GGML_ASSERT(ggml_can_repeat(b, a));
  GGML_ASSERT(ggml_can_repeat_rows(b, a))if (!(ggml_can_repeat_rows(b, a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2060, "GGML_ASSERT(%s) failed", "ggml_can_repeat_rows(b, a)"
);

  // currently only supported for quantized input and f16
  GGML_ASSERT(ggml_is_quantized(a->type) ||if (!(ggml_is_quantized(a->type) || a->type == GGML_TYPE_F16
 || a->type == GGML_TYPE_BF16)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2065, "GGML_ASSERT(%s) failed", "ggml_is_quantized(a->type) || a->type == GGML_TYPE_F16 || a->type == GGML_TYPE_BF16"
)
              a->type == GGML_TYPE_F16 ||if (!(ggml_is_quantized(a->type) || a->type == GGML_TYPE_F16
 || a->type == GGML_TYPE_BF16)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2065, "GGML_ASSERT(%s) failed", "ggml_is_quantized(a->type) || a->type == GGML_TYPE_F16 || a->type == GGML_TYPE_BF16"
)
              a->type == GGML_TYPE_BF16)if (!(ggml_is_quantized(a->type) || a->type == GGML_TYPE_F16
 || a->type == GGML_TYPE_BF16)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2065, "GGML_ASSERT(%s) failed", "ggml_is_quantized(a->type) || a->type == GGML_TYPE_F16 || a->type == GGML_TYPE_BF16"
);

  struct ggml_tensor * result = ggml_new_tensor(ctx, type, GGML_MAX_DIMS4, a->ne);

  result->op     = GGML_OP_ADD;
  result->src[0] = a;
  result->src[1] = b;

  return result;
2074}

2076struct ggml_tensor * ggml_add_cast(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      enum   ggml_type      type) {
  return ggml_add_cast_impl(ctx, a, b, type);
2082}

2084struct ggml_tensor * ggml_add_id(
          struct ggml_context * ctx,
          struct ggml_tensor  * a,
          struct ggml_tensor  * b,
          struct ggml_tensor  * ids) {

  GGML_ASSERT(a->ne[0] == b->ne[0])if (!(a->ne[0] == b->ne[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2090, "GGML_ASSERT(%s) failed", "a->ne[0] == b->ne[0]"
);
  GGML_ASSERT(a->ne[1] == ids->ne[0])if (!(a->ne[1] == ids->ne[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2091, "GGML_ASSERT(%s) failed", "a->ne[1] == ids->ne[0]"
);
  GGML_ASSERT(a->ne[2] == ids->ne[1])if (!(a->ne[2] == ids->ne[1])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2092, "GGML_ASSERT(%s) failed", "a->ne[2] == ids->ne[1]"
);
  GGML_ASSERT(ids->type == GGML_TYPE_I32)if (!(ids->type == GGML_TYPE_I32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2093, "GGML_ASSERT(%s) failed", "ids->type == GGML_TYPE_I32"
);

  struct ggml_tensor * result = ggml_dup_tensor(ctx, a);

  result->op     = GGML_OP_ADD_ID;
  result->src[0] = a;
  result->src[1] = b;
  result->src[2] = ids;

  return result;
2103}

2105// ggml_add1

2107static struct ggml_tensor * ggml_add1_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      bool_Bool                  inplace) {
  GGML_ASSERT(ggml_is_scalar(b))if (!(ggml_is_scalar(b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2112, "GGML_ASSERT(%s) failed", "ggml_is_scalar(b)");
  GGML_ASSERT(ggml_is_padded_1d(a))if (!(ggml_is_padded_1d(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2113, "GGML_ASSERT(%s) failed", "ggml_is_padded_1d(a)");

  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  result->op     = GGML_OP_ADD1;
  result->src[0] = a;
  result->src[1] = b;

  return result;
2122}

2124struct ggml_tensor * ggml_add1(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_add1_impl(ctx, a, b, false0);
2129}

2131struct ggml_tensor * ggml_add1_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_add1_impl(ctx, a, b, true1);
2136}

2138// ggml_acc

2140static struct ggml_tensor * ggml_acc_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      size_t                nb1,
      size_t                nb2,
      size_t                nb3,
      size_t                offset,
      bool_Bool                  inplace) {
  GGML_ASSERT(ggml_nelements(b) <= ggml_nelements(a))if (!(ggml_nelements(b) <= ggml_nelements(a))) ggml_abort(
"/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2149, "GGML_ASSERT(%s) failed", "ggml_nelements(b) <= ggml_nelements(a)"
);
  GGML_ASSERT(ggml_is_contiguous(a))if (!(ggml_is_contiguous(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2150, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(a)");
  GGML_ASSERT(a->type == GGML_TYPE_F32)if (!(a->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2151, "GGML_ASSERT(%s) failed", "a->type == GGML_TYPE_F32"
);
  GGML_ASSERT(b->type == GGML_TYPE_F32)if (!(b->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2152, "GGML_ASSERT(%s) failed", "b->type == GGML_TYPE_F32"
);

  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  int32_t params[] = { nb1, nb2, nb3, offset, inplace ? 1 : 0 };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_ACC;
  result->src[0] = a;
  result->src[1] = b;

  return result;
2164}

2166struct ggml_tensor * ggml_acc(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      size_t                nb1,
      size_t                nb2,
      size_t                nb3,
      size_t                offset) {
  return ggml_acc_impl(ctx, a, b, nb1, nb2, nb3, offset, false0);
2175}

2177struct ggml_tensor * ggml_acc_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      size_t                nb1,
      size_t                nb2,
      size_t                nb3,
      size_t                offset) {
  return ggml_acc_impl(ctx, a, b, nb1, nb2, nb3, offset, true1);
2186}

2188// ggml_sub

2190static struct ggml_tensor * ggml_sub_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      bool_Bool                  inplace) {
  GGML_ASSERT(ggml_can_repeat(b, a))if (!(ggml_can_repeat(b, a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2195, "GGML_ASSERT(%s) failed", "ggml_can_repeat(b, a)");

  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  result->op     = GGML_OP_SUB;
  result->src[0] = a;
  result->src[1] = b;

  return result;
2204}

2206struct ggml_tensor * ggml_sub(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_sub_impl(ctx, a, b, false0);
2211}

2213struct ggml_tensor * ggml_sub_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_sub_impl(ctx, a, b, true1);
2218}

2220// ggml_mul

2222static struct ggml_tensor * ggml_mul_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      bool_Bool                  inplace) {
  GGML_ASSERT(ggml_can_repeat(b, a))if (!(ggml_can_repeat(b, a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2227, "GGML_ASSERT(%s) failed", "ggml_can_repeat(b, a)");
20
←
Assuming the condition is false→

  struct ggml_tensor * result = inplace21.1
'inplace' is false
 ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
21
←
Taking false branch→
22
←
'?' condition is false→
23
←
Passing null pointer value via 2nd parameter 'src'→
24
←
Calling 'ggml_dup_tensor'→

  result->op     = GGML_OP_MUL;
  result->src[0] = a;
  result->src[1] = b;

  return result;
2236}

2238struct ggml_tensor * ggml_mul(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_mul_impl(ctx, a, b, false0);
18
←
Passing null pointer value via 2nd parameter 'a'→
19
←
Calling 'ggml_mul_impl'→
2243}

2245struct ggml_tensor * ggml_mul_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_mul_impl(ctx, a, b, true1);
2250}

2252// ggml_div

2254static struct ggml_tensor * ggml_div_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      bool_Bool                  inplace) {
  GGML_ASSERT(ggml_can_repeat(b, a))if (!(ggml_can_repeat(b, a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2259, "GGML_ASSERT(%s) failed", "ggml_can_repeat(b, a)");

  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  result->op     = GGML_OP_DIV;
  result->src[0] = a;
  result->src[1] = b;

  return result;
2268}

2270struct ggml_tensor * ggml_div(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_div_impl(ctx, a, b, false0);
2275}

2277struct ggml_tensor * ggml_div_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_div_impl(ctx, a, b, true1);
2282}

2284// ggml_sqr

2286static struct ggml_tensor * ggml_sqr_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      bool_Bool                  inplace) {
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  result->op     = GGML_OP_SQR;
  result->src[0] = a;

  return result;
2296}

2298struct ggml_tensor * ggml_sqr(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_sqr_impl(ctx, a, false0);
2302}

2304struct ggml_tensor * ggml_sqr_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_sqr_impl(ctx, a, true1);
2308}

2310// ggml_sqrt

2312static struct ggml_tensor * ggml_sqrt_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      bool_Bool                  inplace) {
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  result->op     = GGML_OP_SQRT;
  result->src[0] = a;

  return result;
2322}

2324struct ggml_tensor * ggml_sqrt(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_sqrt_impl(ctx, a, false0);
2328}

2330struct ggml_tensor * ggml_sqrt_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_sqrt_impl(ctx, a, true1);
2334}

2336// ggml_log

2338static struct ggml_tensor * ggml_log_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      bool_Bool                  inplace) {
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  result->op     = GGML_OP_LOG;
  result->src[0] = a;

  return result;
2348}

2350struct ggml_tensor * ggml_log(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_log_impl(ctx, a, false0);
2354}

2356struct ggml_tensor * ggml_log_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_log_impl(ctx, a, true1);
2360}

2362struct ggml_tensor * ggml_expm1(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_EXPM1);
2366}

2368struct ggml_tensor * ggml_expm1_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_EXPM1);
2372}

2374struct ggml_tensor * ggml_softplus(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_SOFTPLUS);
2378}

2380struct ggml_tensor * ggml_softplus_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_SOFTPLUS);
2384}

2386// ggml_sin

2388static struct ggml_tensor * ggml_sin_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      bool_Bool                  inplace) {
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  result->op     = GGML_OP_SIN;
  result->src[0] = a;

  return result;
2398}

2400struct ggml_tensor * ggml_sin(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_sin_impl(ctx, a, false0);
2404}

2406struct ggml_tensor * ggml_sin_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_sin_impl(ctx, a, true1);
2410}

2412// ggml_cos

2414static struct ggml_tensor * ggml_cos_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      bool_Bool                  inplace) {
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  result->op     = GGML_OP_COS;
  result->src[0] = a;

  return result;
2424}

2426struct ggml_tensor * ggml_cos(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_cos_impl(ctx, a, false0);
2430}

2432struct ggml_tensor * ggml_cos_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_cos_impl(ctx, a, true1);
2436}

2438// ggml_sum

2440struct ggml_tensor * ggml_sum(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  struct ggml_tensor * result = ggml_new_tensor_1d(ctx, a->type, 1);

  result->op     = GGML_OP_SUM;
  result->src[0] = a;

  return result;
2449}

2451// ggml_sum_rows

2453struct ggml_tensor * ggml_sum_rows(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  int64_t ne[GGML_MAX_DIMS4] = { 1 };
  for (int i = 1; i < GGML_MAX_DIMS4; ++i) {
      ne[i] = a->ne[i];
  }

  struct ggml_tensor * result = ggml_new_tensor(ctx, a->type, GGML_MAX_DIMS4, ne);

  result->op     = GGML_OP_SUM_ROWS;
  result->src[0] = a;

  return result;
2467}

2469// ggml_cumsum

2471struct ggml_tensor * ggml_cumsum(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  GGML_ASSERT(a->type == GGML_TYPE_F32)if (!(a->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2474, "GGML_ASSERT(%s) failed", "a->type == GGML_TYPE_F32"
);

  struct ggml_tensor * result = ggml_dup_tensor(ctx, a);

  result->op     = GGML_OP_CUMSUM;
  result->src[0] = a;

  return result;
2482}

2484// ggml_mean

2486struct ggml_tensor * ggml_mean(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  int64_t ne[4] = { 1, a->ne[1], a->ne[2], a->ne[3] };
  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  result->op     = GGML_OP_MEAN;
  result->src[0] = a;

  return result;
2496}

2498// ggml_argmax

2500struct ggml_tensor * ggml_argmax(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  GGML_ASSERT(ggml_is_matrix(a))if (!(ggml_is_matrix(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2503, "GGML_ASSERT(%s) failed", "ggml_is_matrix(a)");
  GGML_ASSERT(a->ne[0] <= INT32_MAX)if (!(a->ne[0] <= (2147483647))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2504, "GGML_ASSERT(%s) failed", "a->ne[0] <= INT32_MAX"
);

  struct ggml_tensor * result = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, a->ne[1]);

  result->op     = GGML_OP_ARGMAX;
  result->src[0] = a;

  return result;
2512}

2514// ggml_count_equal

2516struct ggml_tensor * ggml_count_equal(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  GGML_ASSERT(ggml_are_same_shape(a, b))if (!(ggml_are_same_shape(a, b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2520, "GGML_ASSERT(%s) failed", "ggml_are_same_shape(a, b)"
);

  struct ggml_tensor * result = ggml_new_tensor_1d(ctx, GGML_TYPE_I64, 1);

  result->op     = GGML_OP_COUNT_EQUAL;
  result->src[0] = a;
  result->src[1] = b;

  return result;
2529}

2531// ggml_repeat

2533struct ggml_tensor * ggml_repeat(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  GGML_ASSERT(ggml_can_repeat(a, b))if (!(ggml_can_repeat(a, b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2537, "GGML_ASSERT(%s) failed", "ggml_can_repeat(a, b)");

  struct ggml_tensor * result = ggml_new_tensor(ctx, a->type, GGML_MAX_DIMS4, b->ne);

  result->op     = GGML_OP_REPEAT;
  result->src[0] = a;

  return result;
2545}

2547struct ggml_tensor * ggml_repeat_4d(
      struct ggml_context * ctx,
      struct ggml_tensor * a,
      int64_t ne0, int64_t ne1, int64_t ne2, int64_t ne3) {
  const bool_Bool can_repeat = ggml_is_empty(a) || (
      (ne0 % a->ne[0] == 0) &&
      (ne1 % a->ne[1] == 0) &&
      (ne2 % a->ne[2] == 0) &&
      (ne3 % a->ne[3] == 0)
  );
  GGML_ASSERT(can_repeat)if (!(can_repeat)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2557, "GGML_ASSERT(%s) failed", "can_repeat");

  struct ggml_tensor * result = ggml_new_tensor_4d(ctx, a->type, ne0, ne1, ne2, ne3);

  result->op     = GGML_OP_REPEAT;
  result->src[0] = a;

  return result;
2565}

2567// ggml_repeat_back

2569struct ggml_tensor * ggml_repeat_back(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  GGML_ASSERT(ggml_can_repeat(b, a))if (!(ggml_can_repeat(b, a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2573, "GGML_ASSERT(%s) failed", "ggml_can_repeat(b, a)");

  struct ggml_tensor * result = ggml_new_tensor(ctx, a->type, GGML_MAX_DIMS4, b->ne);

  result->op     = GGML_OP_REPEAT_BACK;
  result->src[0] = a;

  return result;
2581}

2583// ggml_concat

2585struct ggml_tensor * ggml_concat(
  struct ggml_context * ctx,
  struct ggml_tensor  * a,
  struct ggml_tensor  * b,
  int                   dim) {
  GGML_ASSERT(dim >= 0 && dim < GGML_MAX_DIMS)if (!(dim >= 0 && dim < 4)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2590, "GGML_ASSERT(%s) failed", "dim >= 0 && dim < GGML_MAX_DIMS"
);
  GGML_ASSERT(a->type == b->type)if (!(a->type == b->type)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2591, "GGML_ASSERT(%s) failed", "a->type == b->type");

  int64_t ne[GGML_MAX_DIMS4];
  for (int d = 0; d < GGML_MAX_DIMS4; ++d) {
      if (d == dim) {
          ne[d] = a->ne[d] + b->ne[d];
          continue;
      }
      GGML_ASSERT(a->ne[d] == b->ne[d])if (!(a->ne[d] == b->ne[d])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2599, "GGML_ASSERT(%s) failed", "a->ne[d] == b->ne[d]"
);
      ne[d] = a->ne[d];
  }

  struct ggml_tensor * result = ggml_new_tensor(ctx, a->type, GGML_MAX_DIMS4, ne);

  ggml_set_op_params_i32(result, 0, dim);

  result->op     = GGML_OP_CONCAT;
  result->src[0] = a;
  result->src[1] = b;

  return result;
2612}

2614// ggml_abs

2616struct ggml_tensor * ggml_abs(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_ABS);
2620}

2622struct ggml_tensor * ggml_abs_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_ABS);
2626}

2628// ggml_sgn

2630struct ggml_tensor * ggml_sgn(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_SGN);
2634}

2636struct ggml_tensor * ggml_sgn_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_SGN);
2640}

2642// ggml_neg

2644struct ggml_tensor * ggml_neg(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_NEG);
2648}

2650struct ggml_tensor * ggml_neg_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_NEG);
2654}

2656// ggml_step

2658struct ggml_tensor * ggml_step(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_STEP);
2662}

2664struct ggml_tensor * ggml_step_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_STEP);
2668}

2670// ggml_tanh

2672struct ggml_tensor * ggml_tanh(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_TANH);
2676}

2678struct ggml_tensor * ggml_tanh_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_TANH);
2682}

2684// ggml_elu

2686struct ggml_tensor * ggml_elu(
  struct ggml_context * ctx,
  struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_ELU);
2690}

2692struct ggml_tensor * ggml_elu_inplace(
  struct ggml_context * ctx,
  struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_ELU);
2696}

2698// ggml_relu

2700struct ggml_tensor * ggml_relu(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_RELU);
2704}

2706struct ggml_tensor * ggml_relu_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_RELU);
2710}

2712// ggml_leaky_relu

2714struct ggml_tensor * ggml_leaky_relu(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 negative_slope,
      bool_Bool                  inplace) {
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  ggml_set_op_params(result, &negative_slope, sizeof(negative_slope));

  result->op     = GGML_OP_LEAKY_RELU;
  result->src[0] = a;

  return result;
2727}

2729// ggml_sigmoid

2731struct ggml_tensor * ggml_sigmoid(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_SIGMOID);
2735}

2737struct ggml_tensor * ggml_sigmoid_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_SIGMOID);
2741}

2743// ggml_gelu

2745struct ggml_tensor * ggml_gelu(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_GELU);
2749}

2751struct ggml_tensor * ggml_gelu_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_GELU);
2755}

2757// ggml_gelu_erf

2759struct ggml_tensor * ggml_gelu_erf(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_GELU_ERF);
2763}

2765struct ggml_tensor * ggml_gelu_erf_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_GELU_ERF);
2769}

2771// ggml_gelu_quick

2773struct ggml_tensor * ggml_gelu_quick(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_GELU_QUICK);
2777}

2779struct ggml_tensor * ggml_gelu_quick_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_GELU_QUICK);
2783}

2785// ggml_silu

2787struct ggml_tensor * ggml_silu(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_SILU);
2791}

2793struct ggml_tensor * ggml_silu_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_SILU);
2797}

2799// ggml_xielu

2801struct ggml_tensor * ggml_xielu(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float alpha_n,
      float alpha_p,
      float beta,
      float eps) {
  struct ggml_tensor * result = ggml_dup_tensor(ctx, a);

  ggml_set_op_params_i32(result, 0, (int32_t) GGML_UNARY_OP_XIELU);
  ggml_set_op_params_f32(result, 1, beta + ggml_compute_softplus_f32(alpha_n));
  ggml_set_op_params_f32(result, 2, ggml_compute_softplus_f32(alpha_p));
  ggml_set_op_params_f32(result, 3, beta);
  ggml_set_op_params_f32(result, 4, eps);

  result->op     = GGML_OP_UNARY;
  result->src[0] = a;

  return result;
2820}

2822// ggml_silu_back

2824struct ggml_tensor * ggml_silu_back(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  struct ggml_tensor * result = ggml_dup_tensor(ctx, a);

  result->op     = GGML_OP_SILU_BACK;
  result->src[0] = a;
  result->src[1] = b;

  return result;
2835}

2837// ggml hardswish

2839struct ggml_tensor * ggml_hardswish(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_HARDSWISH);
2843}

2845// ggml hardsigmoid

2847struct ggml_tensor * ggml_hardsigmoid(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_HARDSIGMOID);
2851}

2853// ggml exp

2855struct ggml_tensor * ggml_exp(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_EXP);
2859}

2861struct ggml_tensor * ggml_exp_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_EXP);
2865}

2867// ggml_glu

2869static struct ggml_tensor * ggml_glu_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      enum ggml_glu_op      op,
      bool_Bool                  swapped) {
  GGML_ASSERT(ggml_is_contiguous_1(a))if (!(ggml_is_contiguous_1(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2875, "GGML_ASSERT(%s) failed", "ggml_is_contiguous_1(a)");

  if (b) {
      GGML_ASSERT(ggml_is_contiguous_1(b))if (!(ggml_is_contiguous_1(b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2878, "GGML_ASSERT(%s) failed", "ggml_is_contiguous_1(b)");
      GGML_ASSERT(ggml_are_same_shape(a, b))if (!(ggml_are_same_shape(a, b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2879, "GGML_ASSERT(%s) failed", "ggml_are_same_shape(a, b)"
);
      GGML_ASSERT(a->type == b->type)if (!(a->type == b->type)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 2880, "GGML_ASSERT(%s) failed", "a->type == b->type");
  }

  int64_t ne[GGML_MAX_DIMS4] = { a->ne[0] / 2 }; for (int i = 1; i < GGML_MAX_DIMS4; i++) ne[i] = a->ne[i];
  struct ggml_tensor * result = ggml_new_tensor_impl(ctx, a->type, GGML_MAX_DIMS4, b ? a->ne : ne, NULL((void*)0), 0);

  ggml_set_op_params_i32(result, 0, (int32_t) op);
  ggml_set_op_params_i32(result, 1, (int32_t) swapped);

  result->op     = GGML_OP_GLU;
  result->src[0] = a;
  result->src[1] = b;

  return result;
2894}

2896// ggml_floor

2898struct ggml_tensor * ggml_floor(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_FLOOR);
2902}

2904struct ggml_tensor * ggml_floor_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_FLOOR);
2908}

2910// ggml_ceil

2912struct ggml_tensor * ggml_ceil(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_CEIL);
2916}

2918struct ggml_tensor * ggml_ceil_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_CEIL);
2922}

2924//ggml_round

2926struct ggml_tensor * ggml_round(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_ROUND);
2930}

2932struct ggml_tensor * ggml_round_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_ROUND);
2936}

2938//ggml_trunc

2940struct ggml_tensor * ggml_trunc(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary(ctx, a, GGML_UNARY_OP_TRUNC);
2944}

2946struct ggml_tensor * ggml_trunc_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_unary_inplace(ctx, a, GGML_UNARY_OP_TRUNC);
2950}

2952struct ggml_tensor * ggml_glu(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      enum ggml_glu_op      op,
      bool_Bool                  swapped) {
  return ggml_glu_impl(ctx, a, NULL((void*)0), op, swapped);
2958}

2960struct ggml_tensor * ggml_glu_split(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      enum ggml_glu_op      op) {
  return ggml_glu_impl(ctx, a, b, op, false0);
2966}

2968// ggml_reglu

2970struct ggml_tensor * ggml_reglu(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_glu_impl(ctx, a, NULL((void*)0), GGML_GLU_OP_REGLU, false0);
2974}

2976struct ggml_tensor * ggml_reglu_swapped(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_glu_impl(ctx, a, NULL((void*)0), GGML_GLU_OP_REGLU, true1);
2980}

2982struct ggml_tensor * ggml_reglu_split(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_glu_impl(ctx, a, b, GGML_GLU_OP_REGLU, false0);
2987}

2989// ggml_geglu

2991struct ggml_tensor * ggml_geglu(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_glu_impl(ctx, a, NULL((void*)0), GGML_GLU_OP_GEGLU, false0);
2995}

2997struct ggml_tensor * ggml_geglu_swapped(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_glu_impl(ctx, a, NULL((void*)0), GGML_GLU_OP_GEGLU, true1);
3001}

3003struct ggml_tensor * ggml_geglu_split(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_glu_impl(ctx, a, b, GGML_GLU_OP_GEGLU, false0);
3008}

3010// ggml_swiglu

3012struct ggml_tensor * ggml_swiglu(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_glu_impl(ctx, a, NULL((void*)0), GGML_GLU_OP_SWIGLU, false0);
3016}

3018struct ggml_tensor * ggml_swiglu_swapped(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_glu_impl(ctx, a, NULL((void*)0), GGML_GLU_OP_SWIGLU, true1);
3022}

3024struct ggml_tensor * ggml_swiglu_split(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_glu_impl(ctx, a, b, GGML_GLU_OP_SWIGLU, false0);
3029}

3031// ggml_geglu_erf

3033struct ggml_tensor * ggml_geglu_erf(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_glu_impl(ctx, a, NULL((void*)0), GGML_GLU_OP_GEGLU_ERF, false0);
3037}

3039struct ggml_tensor * ggml_geglu_erf_swapped(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_glu_impl(ctx, a, NULL((void*)0), GGML_GLU_OP_GEGLU_ERF, true1);
3043}

3045struct ggml_tensor * ggml_geglu_erf_split(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_glu_impl(ctx, a, b, GGML_GLU_OP_GEGLU_ERF, false0);
3050}

3052// ggml_geglu_quick

3054struct ggml_tensor * ggml_geglu_quick(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_glu_impl(ctx, a, NULL((void*)0), GGML_GLU_OP_GEGLU_QUICK, false0);
3058}

3060struct ggml_tensor * ggml_geglu_quick_swapped(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_glu_impl(ctx, a, NULL((void*)0), GGML_GLU_OP_GEGLU_QUICK, true1);
3064}

3066struct ggml_tensor * ggml_geglu_quick_split(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_glu_impl(ctx, a, b, GGML_GLU_OP_GEGLU_QUICK, false0);
3071}

3073struct ggml_tensor * ggml_swiglu_oai(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      float                 alpha,
      float                 limit) {
  struct ggml_tensor * result = ggml_glu_impl(ctx, a, b, GGML_GLU_OP_SWIGLU_OAI, false0);
  ggml_set_op_params_f32(result, 2, alpha);
  ggml_set_op_params_f32(result, 3, limit);

  return result;
3084}

3086// ggml_norm

3088static struct ggml_tensor * ggml_norm_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 eps,
      bool_Bool                  inplace) {
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  ggml_set_op_params(result, &eps, sizeof(eps));

  result->op     = GGML_OP_NORM;
  result->src[0] = a;

  return result;
3101}

3103struct ggml_tensor * ggml_norm(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 eps) {
  return ggml_norm_impl(ctx, a, eps, false0);
3108}

3110struct ggml_tensor * ggml_norm_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 eps) {
  return ggml_norm_impl(ctx, a, eps, true1);
3115}

3117// ggml_rms_norm

3119static struct ggml_tensor * ggml_rms_norm_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 eps,
      bool_Bool                  inplace) {
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  ggml_set_op_params(result, &eps, sizeof(eps));

  result->op     = GGML_OP_RMS_NORM;
  result->src[0] = a;

  return result;
3132}

3134struct ggml_tensor * ggml_rms_norm(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 eps) {
  return ggml_rms_norm_impl(ctx, a, eps, false0);
3139}

3141struct ggml_tensor * ggml_rms_norm_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 eps) {
  return ggml_rms_norm_impl(ctx, a, eps, true1);
3146}

3148// ggml_rms_norm_back

3150struct ggml_tensor * ggml_rms_norm_back(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      float                 eps) {
  struct ggml_tensor * result = ggml_dup_tensor(ctx, a);

  ggml_set_op_params(result, &eps, sizeof(eps));

  result->op     = GGML_OP_RMS_NORM_BACK;
  result->src[0] = a;
  result->src[1] = b;

  return result;
3164}

3166// ggml_group_norm

3168static struct ggml_tensor * ggml_group_norm_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   n_groups,
      float                 eps,
      bool_Bool                  inplace) {
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  ggml_set_op_params_i32(result, 0, n_groups);
  ggml_set_op_params_f32(result, 1, eps);

  result->op     = GGML_OP_GROUP_NORM;
  result->src[0] = a;

  return result;
3183}

3185struct ggml_tensor * ggml_group_norm(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   n_groups,
      float                 eps) {
  return ggml_group_norm_impl(ctx, a, n_groups, eps, false0);
3191}

3193struct ggml_tensor * ggml_group_norm_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   n_groups,
      float                 eps) {
  return ggml_group_norm_impl(ctx, a, n_groups, eps, true1);
3199}

3201// ggml_l2_norm

3203static struct ggml_tensor * ggml_l2_norm_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 eps,
      bool_Bool                  inplace) {
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  ggml_set_op_params_f32(result, 0, eps);

  result->op     = GGML_OP_L2_NORM;
  result->src[0] = a;

  return result;
3216}

3218struct ggml_tensor * ggml_l2_norm(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 eps) {
  return ggml_l2_norm_impl(ctx, a, eps, false0);
3223}

3225struct ggml_tensor * ggml_l2_norm_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 eps) {
  return ggml_l2_norm_impl(ctx, a, eps, true1);
3230}

3232// ggml_mul_mat

3234static inline bool_Bool ggml_can_mul_mat(const struct ggml_tensor * t0, const struct ggml_tensor * t1) {
  static_assert_Static_assert(GGML_MAX_DIMS4 == 4, "GGML_MAX_DIMS is not 4 - update this function");

  return (t0->ne[0]           == t1->ne[0])  &&
         (t1->ne[2]%t0->ne[2] == 0)          && // verify t0 is broadcastable
         (t1->ne[3]%t0->ne[3] == 0);
3240}

3242struct ggml_tensor * ggml_mul_mat(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  GGML_ASSERT(ggml_can_mul_mat(a, b))if (!(ggml_can_mul_mat(a, b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3246, "GGML_ASSERT(%s) failed", "ggml_can_mul_mat(a, b)");
  GGML_ASSERT(!ggml_is_transposed(a))if (!(!ggml_is_transposed(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3247, "GGML_ASSERT(%s) failed", "!ggml_is_transposed(a)");

  const int64_t ne[4] = { a->ne[1], b->ne[1], b->ne[2], b->ne[3] };
  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  result->op     = GGML_OP_MUL_MAT;
  result->src[0] = a;
  result->src[1] = b;

  return result;
3257}

3259void ggml_mul_mat_set_prec(
      struct ggml_tensor * a,
      enum ggml_prec       prec) {
  GGML_ASSERT(a->op == GGML_OP_MUL_MAT)if (!(a->op == GGML_OP_MUL_MAT)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3262, "GGML_ASSERT(%s) failed", "a->op == GGML_OP_MUL_MAT"
);

  const int32_t prec_i32 = (int32_t) prec;

  ggml_set_op_params_i32(a, 0, prec_i32);
3267}

3269void ggml_mul_mat_set_hint(
      struct ggml_tensor * a,
      enum ggml_op_hint    hint) {
  GGML_ASSERT(a->op == GGML_OP_MUL_MAT)if (!(a->op == GGML_OP_MUL_MAT)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3272, "GGML_ASSERT(%s) failed", "a->op == GGML_OP_MUL_MAT"
);

  const int32_t hint_i32 = (int32_t) hint;

  ggml_set_op_params_i32(a, 1, hint_i32);
3277}

3279// ggml_mul_mat_id

3281/*
  c = ggml_mul_mat_id(ctx, as, b, ids);

  as  -> [cols, rows, n_expert]
  b   -> [cols, n_expert_used, n_tokens]
  ids -> [n_expert_used, n_tokens] (i32)
  c   -> [rows, n_expert_used, n_tokens]

  in b, n_expert_used can be broadcasted to match the n_expert_used of ids

  c ~= as[:,:,i] @ b[:,i%r,t], i = ids[e,t] for all e,t in ids
3292*/
3293struct ggml_tensor * ggml_mul_mat_id(
      struct ggml_context * ctx,
      struct ggml_tensor  * as,
      struct ggml_tensor  * b,
      struct ggml_tensor  * ids) {
  GGML_ASSERT(!ggml_is_transposed(as))if (!(!ggml_is_transposed(as))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3298, "GGML_ASSERT(%s) failed", "!ggml_is_transposed(as)");
  GGML_ASSERT(ids->type == GGML_TYPE_I32)if (!(ids->type == GGML_TYPE_I32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3299, "GGML_ASSERT(%s) failed", "ids->type == GGML_TYPE_I32"
);

  GGML_ASSERT(as->ne[3] == 1)if (!(as->ne[3] == 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3301, "GGML_ASSERT(%s) failed", "as->ne[3] == 1"); // as is 3d (one matrix per expert)
  GGML_ASSERT(b->ne[3] == 1)if (!(b->ne[3] == 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3302, "GGML_ASSERT(%s) failed", "b->ne[3] == 1"); // b is 3d
  GGML_ASSERT(ids->ne[2] == 1 && ids->ne[3] == 1)if (!(ids->ne[2] == 1 && ids->ne[3] == 1)) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3303, "GGML_ASSERT(%s) failed", "ids->ne[2] == 1 && ids->ne[3] == 1"
); // ids is 2d
  GGML_ASSERT(ids->ne[1] == b->ne[2])if (!(ids->ne[1] == b->ne[2])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3304, "GGML_ASSERT(%s) failed", "ids->ne[1] == b->ne[2]"
); // must have an expert list per b row
  GGML_ASSERT(as->ne[0] == b->ne[0])if (!(as->ne[0] == b->ne[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3305, "GGML_ASSERT(%s) failed", "as->ne[0] == b->ne[0]"
); // can_mul_mat
  GGML_ASSERT(ids->ne[0] % b->ne[1] == 0)if (!(ids->ne[0] % b->ne[1] == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3306, "GGML_ASSERT(%s) failed", "ids->ne[0] % b->ne[1] == 0"
); // can broadcast

  const int64_t ne[4] = { as->ne[1], ids->ne[0], b->ne[2], 1 };
  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  result->op     = GGML_OP_MUL_MAT_ID;
  result->src[0] = as;
  result->src[1] = b;
  result->src[2] = ids;

  return result;
3317}

3319// ggml_out_prod

3321static inline bool_Bool ggml_can_out_prod(const struct ggml_tensor * t0, const struct ggml_tensor * t1) {
  static_assert_Static_assert(GGML_MAX_DIMS4 == 4, "GGML_MAX_DIMS is not 4 - update this function");

  return (t0->ne[1] == t1->ne[1])   &&
         (t1->ne[2]%t0->ne[2] == 0) && // verify t0 is broadcastable
         (t1->ne[3]%t0->ne[3] == 0);
3327}

3329struct ggml_tensor * ggml_out_prod(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  GGML_ASSERT(ggml_can_out_prod(a, b))if (!(ggml_can_out_prod(a, b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3333, "GGML_ASSERT(%s) failed", "ggml_can_out_prod(a, b)");
  GGML_ASSERT(!ggml_is_transposed(a))if (!(!ggml_is_transposed(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3334, "GGML_ASSERT(%s) failed", "!ggml_is_transposed(a)");

  // a is broadcastable to b for ne[2] and ne[3] -> use b->ne[2] and b->ne[3]
  const int64_t ne[4] = { a->ne[0], b->ne[0], b->ne[2], b->ne[3] };
  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  result->op     = GGML_OP_OUT_PROD;
  result->src[0] = a;
  result->src[1] = b;

  return result;
3345}

3347// ggml_scale

3349static struct ggml_tensor * ggml_scale_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 s,
      float                 b,
      bool_Bool                  inplace) {
  GGML_ASSERT(ggml_is_padded_1d(a))if (!(ggml_is_padded_1d(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3355, "GGML_ASSERT(%s) failed", "ggml_is_padded_1d(a)");

  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  float params[2] = { s, b };
  ggml_set_op_params(result, &params, sizeof(params));

  result->op     = GGML_OP_SCALE;
  result->src[0] = a;

  return result;
3366}

3368struct ggml_tensor * ggml_scale(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 s) {
  return ggml_scale_impl(ctx, a, s, 0.0, false0);
3373}

3375struct ggml_tensor * ggml_scale_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 s) {
  return ggml_scale_impl(ctx, a, s, 0.0, true1);
3380}

3382struct ggml_tensor * ggml_scale_bias(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 s,
      float                 b) {
  return ggml_scale_impl(ctx, a, s, b, false0);
3388}

3390struct ggml_tensor * ggml_scale_bias_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 s,
      float                 b) {
  return ggml_scale_impl(ctx, a, s, b, true1);
3396}

3398// ggml_set

3400static struct ggml_tensor * ggml_set_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      size_t                nb1,
      size_t                nb2,
      size_t                nb3,
      size_t                offset,
      bool_Bool                  inplace) {
  GGML_ASSERT(ggml_nelements(a) >= ggml_nelements(b))if (!(ggml_nelements(a) >= ggml_nelements(b))) ggml_abort(
"/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3409, "GGML_ASSERT(%s) failed", "ggml_nelements(a) >= ggml_nelements(b)"
);

  // make a view of the destination
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  GGML_ASSERT(offset < (size_t)(1 << 30))if (!(offset < (size_t)(1 << 30))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3414, "GGML_ASSERT(%s) failed", "offset < (size_t)(1 << 30)"
);
  int32_t params[] = { nb1, nb2, nb3, offset, inplace ? 1 : 0 };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_SET;
  result->src[0] = a;
  result->src[1] = b;

  return result;
3423}

3425struct ggml_tensor * ggml_set(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      size_t                nb1,
      size_t                nb2,
      size_t                nb3,
      size_t                offset) {
  return ggml_set_impl(ctx, a, b, nb1, nb2, nb3, offset, false0);
3434}

3436struct ggml_tensor * ggml_set_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      size_t                nb1,
      size_t                nb2,
      size_t                nb3,
      size_t                offset) {
  return ggml_set_impl(ctx, a, b, nb1, nb2, nb3, offset, true1);
3445}

3447struct ggml_tensor * ggml_set_1d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      size_t                offset) {
  return ggml_set_impl(ctx, a, b, a->nb[1], a->nb[2], a->nb[3], offset, false0);
3453}

3455struct ggml_tensor * ggml_set_1d_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      size_t                offset) {
  return ggml_set_impl(ctx, a, b, a->nb[1], a->nb[2], a->nb[3], offset, true1);
3461}

3463struct ggml_tensor * ggml_set_2d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      size_t                nb1,
      size_t                offset) {
  return ggml_set_impl(ctx, a, b, nb1, a->nb[2], a->nb[3], offset, false0);
3470}

3472struct ggml_tensor * ggml_set_2d_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      size_t                nb1,
      size_t                offset) {
  return ggml_set_impl(ctx, a, b, nb1, a->nb[2], a->nb[3], offset, true1);
3479}

3481// ggml_cpy

3483static struct ggml_tensor * ggml_cpy_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  GGML_ASSERT(ggml_nelements(a) == ggml_nelements(b))if (!(ggml_nelements(a) == ggml_nelements(b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3487, "GGML_ASSERT(%s) failed", "ggml_nelements(a) == ggml_nelements(b)"
);

  // make a view of the destination
  struct ggml_tensor * result = ggml_view_tensor(ctx, b);
  if (strlen(b->name) > 0) {
      ggml_format_name(result, "%s (copy of %s)", b->name, a->name);
  } else {
      ggml_format_name(result, "%s (copy)", a->name);
  }

  result->op     = GGML_OP_CPY;
  result->src[0] = a;
  result->src[1] = b;

  return result;
3502}

3504struct ggml_tensor * ggml_cpy(
      struct ggml_context * ctx,
      struct ggml_tensor * a,
      struct ggml_tensor * b) {
  return ggml_cpy_impl(ctx, a, b);
3509}

3511struct ggml_tensor * ggml_cast(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      enum   ggml_type      type) {
  struct ggml_tensor * result = ggml_new_tensor(ctx, type, GGML_MAX_DIMS4, a->ne);
  ggml_format_name(result, "%s (copy)", a->name);

  result->op     = GGML_OP_CPY;
  result->src[0] = a;
  result->src[1] = result; // note: this self-reference might seem redundant, but it's actually needed by some
                           //       backends for consistency with ggml_cpy_impl() above

  return result;
3524}

3526// ggml_cont

3528static struct ggml_tensor * ggml_cont_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  struct ggml_tensor * result = ggml_dup_tensor(ctx, a);
  ggml_format_name(result, "%s (cont)", a->name);

  result->op     = GGML_OP_CONT;
  result->src[0] = a;

  return result;
3538}

3540struct ggml_tensor * ggml_cont(
      struct ggml_context * ctx,
      struct ggml_tensor * a) {
  return ggml_cont_impl(ctx, a);
3544}

3546// make contiguous, with new shape
3547GGML_API__attribute__ ((visibility ("default"))) extern struct ggml_tensor * ggml_cont_1d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int64_t               ne0) {
  return ggml_cont_4d(ctx, a, ne0, 1, 1, 1);
3552}

3554GGML_API__attribute__ ((visibility ("default"))) extern struct ggml_tensor * ggml_cont_2d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int64_t               ne0,
      int64_t               ne1) {
  return ggml_cont_4d(ctx, a, ne0, ne1, 1, 1);
3560}

3562GGML_API__attribute__ ((visibility ("default"))) extern struct ggml_tensor * ggml_cont_3d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int64_t               ne0,
      int64_t               ne1,
      int64_t               ne2) {
  return ggml_cont_4d(ctx, a, ne0, ne1, ne2, 1);
3569}

3571struct ggml_tensor * ggml_cont_4d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int64_t               ne0,
      int64_t               ne1,
      int64_t               ne2,
      int64_t               ne3) {
  GGML_ASSERT(ggml_nelements(a) == (ne0*ne1*ne2*ne3))if (!(ggml_nelements(a) == (ne0*ne1*ne2*ne3))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3578, "GGML_ASSERT(%s) failed", "ggml_nelements(a) == (ne0*ne1*ne2*ne3)"
);

  struct ggml_tensor * result = ggml_new_tensor_4d(ctx, a->type, ne0, ne1, ne2, ne3);
  ggml_format_name(result, "%s (cont)", a->name);

  result->op     = GGML_OP_CONT;
  result->src[0] = a;

  return result;
3587}

3589// ggml_reshape

3591struct ggml_tensor * ggml_reshape(
      struct ggml_context * ctx,
      struct ggml_tensor * a,
      struct ggml_tensor * b) {
  GGML_ASSERT(ggml_is_contiguous(a))if (!(ggml_is_contiguous(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3595, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(a)");
  // as only the shape of b is relevant, and not its memory layout, b is allowed to be non contiguous.
  GGML_ASSERT(ggml_nelements(a) == ggml_nelements(b))if (!(ggml_nelements(a) == ggml_nelements(b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3597, "GGML_ASSERT(%s) failed", "ggml_nelements(a) == ggml_nelements(b)"
);

  struct ggml_tensor * result = ggml_new_tensor_impl(ctx, a->type, GGML_MAX_DIMS4, b->ne, a, 0);
  ggml_format_name(result, "%s (reshaped)", a->name);

  result->op     = GGML_OP_RESHAPE;
  result->src[0] = a;

  return result;
3606}

3608struct ggml_tensor * ggml_reshape_1d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int64_t               ne0) {
  GGML_ASSERT(ggml_is_contiguous(a))if (!(ggml_is_contiguous(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3612, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(a)");
  GGML_ASSERT(ggml_nelements(a) == ne0)if (!(ggml_nelements(a) == ne0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3613, "GGML_ASSERT(%s) failed", "ggml_nelements(a) == ne0");

  const int64_t ne[1] = { ne0 };
  struct ggml_tensor * result = ggml_new_tensor_impl(ctx, a->type, 1, ne, a, 0);
  ggml_format_name(result, "%s (reshaped)", a->name);

  result->op     = GGML_OP_RESHAPE;
  result->src[0] = a;

  return result;
3623}

3625struct ggml_tensor * ggml_reshape_2d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int64_t               ne0,
      int64_t               ne1) {
  GGML_ASSERT(ggml_is_contiguous(a))if (!(ggml_is_contiguous(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3630, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(a)");
  GGML_ASSERT(ggml_nelements(a) == ne0*ne1)if (!(ggml_nelements(a) == ne0*ne1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3631, "GGML_ASSERT(%s) failed", "ggml_nelements(a) == ne0*ne1"
);

  const int64_t ne[2] = { ne0, ne1 };
  struct ggml_tensor * result = ggml_new_tensor_impl(ctx, a->type, 2, ne, a, 0);
  ggml_format_name(result, "%s (reshaped)", a->name);

  result->op     = GGML_OP_RESHAPE;
  result->src[0] = a;

  return result;
3641}

3643struct ggml_tensor * ggml_reshape_3d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int64_t               ne0,
      int64_t               ne1,
      int64_t               ne2) {
  GGML_ASSERT(ggml_is_contiguous(a))if (!(ggml_is_contiguous(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3649, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(a)");
  GGML_ASSERT(ggml_nelements(a) == ne0*ne1*ne2)if (!(ggml_nelements(a) == ne0*ne1*ne2)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3650, "GGML_ASSERT(%s) failed", "ggml_nelements(a) == ne0*ne1*ne2"
);

  const int64_t ne[3] = { ne0, ne1, ne2 };
  struct ggml_tensor * result = ggml_new_tensor_impl(ctx, a->type, 3, ne, a, 0);
  ggml_format_name(result, "%s (reshaped)", a->name);

  result->op     = GGML_OP_RESHAPE;
  result->src[0] = a;

  return result;
3660}

3662struct ggml_tensor * ggml_reshape_4d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int64_t               ne0,
      int64_t               ne1,
      int64_t               ne2,
      int64_t               ne3) {
  GGML_ASSERT(ggml_is_contiguous(a))if (!(ggml_is_contiguous(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3669, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(a)");
  GGML_ASSERT(ggml_nelements(a) == ne0*ne1*ne2*ne3)if (!(ggml_nelements(a) == ne0*ne1*ne2*ne3)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3670, "GGML_ASSERT(%s) failed", "ggml_nelements(a) == ne0*ne1*ne2*ne3"
);

  const int64_t ne[4] = { ne0, ne1, ne2, ne3 };
  struct ggml_tensor * result = ggml_new_tensor_impl(ctx, a->type, 4, ne, a, 0);
  ggml_format_name(result, "%s (reshaped)", a->name);

  result->op     = GGML_OP_RESHAPE;
  result->src[0] = a;

  return result;
3680}

3682static struct ggml_tensor * ggml_view_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   n_dims,
      const int64_t       * ne,
      size_t                offset) {
  struct ggml_tensor * result = ggml_new_tensor_impl(ctx, a->type, n_dims, ne, a, offset);
  ggml_format_name(result, "%s (view)", a->name);

  ggml_set_op_params(result, &offset, sizeof(offset));

  result->op     = GGML_OP_VIEW;
  result->src[0] = a;

  return result;
3697}

3699// ggml_view_1d

3701struct ggml_tensor * ggml_view_1d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int64_t               ne0,
      size_t                offset) {
  struct ggml_tensor * result = ggml_view_impl(ctx, a, 1, &ne0, offset);

  return result;
3709}

3711// ggml_view_2d

3713struct ggml_tensor * ggml_view_2d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int64_t               ne0,
      int64_t               ne1,
      size_t                nb1,
      size_t                offset) {
  const int64_t ne[2] = { ne0, ne1 };

  struct ggml_tensor * result = ggml_view_impl(ctx, a, 2, ne, offset);

  result->nb[1] = nb1;
  result->nb[2] = result->nb[1]*ne1;
  result->nb[3] = result->nb[2];

  return result;
3729}

3731// ggml_view_3d

3733struct ggml_tensor * ggml_view_3d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int64_t               ne0,
      int64_t               ne1,
      int64_t               ne2,
      size_t                nb1,
      size_t                nb2,
      size_t                offset) {
  const int64_t ne[3] = { ne0, ne1, ne2 };

  struct ggml_tensor * result = ggml_view_impl(ctx, a, 3, ne, offset);

  result->nb[1] = nb1;
  result->nb[2] = nb2;
  result->nb[3] = result->nb[2]*ne2;

  return result;
3751}

3753// ggml_view_4d

3755struct ggml_tensor * ggml_view_4d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int64_t               ne0,
      int64_t               ne1,
      int64_t               ne2,
      int64_t               ne3,
      size_t                nb1,
      size_t                nb2,
      size_t                nb3,
      size_t                offset) {
  const int64_t ne[4] = { ne0, ne1, ne2, ne3 };

  struct ggml_tensor * result = ggml_view_impl(ctx, a, 4, ne, offset);

  result->nb[1] = nb1;
  result->nb[2] = nb2;
  result->nb[3] = nb3;

  return result;
3775}

3777// ggml_permute

3779struct ggml_tensor * ggml_permute(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   axis0,
      int                   axis1,
      int                   axis2,
      int                   axis3) {
  GGML_ASSERT(axis0 >= 0 && axis0 < GGML_MAX_DIMS)if (!(axis0 >= 0 && axis0 < 4)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3786, "GGML_ASSERT(%s) failed", "axis0 >= 0 && axis0 < GGML_MAX_DIMS"
);
  GGML_ASSERT(axis1 >= 0 && axis1 < GGML_MAX_DIMS)if (!(axis1 >= 0 && axis1 < 4)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3787, "GGML_ASSERT(%s) failed", "axis1 >= 0 && axis1 < GGML_MAX_DIMS"
);
  GGML_ASSERT(axis2 >= 0 && axis2 < GGML_MAX_DIMS)if (!(axis2 >= 0 && axis2 < 4)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3788, "GGML_ASSERT(%s) failed", "axis2 >= 0 && axis2 < GGML_MAX_DIMS"
);
  GGML_ASSERT(axis3 >= 0 && axis3 < GGML_MAX_DIMS)if (!(axis3 >= 0 && axis3 < 4)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3789, "GGML_ASSERT(%s) failed", "axis3 >= 0 && axis3 < GGML_MAX_DIMS"
);

  GGML_ASSERT(axis0 != axis1)if (!(axis0 != axis1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3791, "GGML_ASSERT(%s) failed", "axis0 != axis1");
  GGML_ASSERT(axis0 != axis2)if (!(axis0 != axis2)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3792, "GGML_ASSERT(%s) failed", "axis0 != axis2");
  GGML_ASSERT(axis0 != axis3)if (!(axis0 != axis3)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3793, "GGML_ASSERT(%s) failed", "axis0 != axis3");
  GGML_ASSERT(axis1 != axis2)if (!(axis1 != axis2)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3794, "GGML_ASSERT(%s) failed", "axis1 != axis2");
  GGML_ASSERT(axis1 != axis3)if (!(axis1 != axis3)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3795, "GGML_ASSERT(%s) failed", "axis1 != axis3");
  GGML_ASSERT(axis2 != axis3)if (!(axis2 != axis3)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3796, "GGML_ASSERT(%s) failed", "axis2 != axis3");

  struct ggml_tensor * result = ggml_view_tensor(ctx, a);
  ggml_format_name(result, "%s (permuted)", a->name);

  int ne[GGML_MAX_DIMS4];
  int nb[GGML_MAX_DIMS4];

  ne[axis0] = a->ne[0];
  ne[axis1] = a->ne[1];
  ne[axis2] = a->ne[2];
  ne[axis3] = a->ne[3];

  nb[axis0] = a->nb[0];
  nb[axis1] = a->nb[1];
  nb[axis2] = a->nb[2];
  nb[axis3] = a->nb[3];

  result->ne[0] = ne[0];
  result->ne[1] = ne[1];
  result->ne[2] = ne[2];
  result->ne[3] = ne[3];

  result->nb[0] = nb[0];
  result->nb[1] = nb[1];
  result->nb[2] = nb[2];
  result->nb[3] = nb[3];

  result->op     = GGML_OP_PERMUTE;
  result->src[0] = a;

  int32_t params[] = { axis0, axis1, axis2, axis3 };
  ggml_set_op_params(result, params, sizeof(params));

  return result;
3831}

3833// ggml_transpose

3835struct ggml_tensor * ggml_transpose(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  struct ggml_tensor * result = ggml_view_tensor(ctx, a);
  ggml_format_name(result, "%s (transposed)", a->name);

  result->ne[0] = a->ne[1];
  result->ne[1] = a->ne[0];

  result->nb[0] = a->nb[1];
  result->nb[1] = a->nb[0];

  result->op     = GGML_OP_TRANSPOSE;
  result->src[0] = a;

  return result;
3851}

3853// ggml_get_rows

3855struct ggml_tensor * ggml_get_rows(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  GGML_ASSERT(a->ne[2] == b->ne[1])if (!(a->ne[2] == b->ne[1])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3859, "GGML_ASSERT(%s) failed", "a->ne[2] == b->ne[1]"
);
  GGML_ASSERT(a->ne[3] == b->ne[2])if (!(a->ne[3] == b->ne[2])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3860, "GGML_ASSERT(%s) failed", "a->ne[3] == b->ne[2]"
);
  GGML_ASSERT(b->ne[3] == 1)if (!(b->ne[3] == 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3861, "GGML_ASSERT(%s) failed", "b->ne[3] == 1");
  GGML_ASSERT(b->type == GGML_TYPE_I32)if (!(b->type == GGML_TYPE_I32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3862, "GGML_ASSERT(%s) failed", "b->type == GGML_TYPE_I32"
);

  // TODO: implement non F32 return
  enum ggml_type type = GGML_TYPE_F32;
  if (a->type == GGML_TYPE_I32) {
      type = a->type;
  }
  struct ggml_tensor * result = ggml_new_tensor_4d(ctx, type, a->ne[0], b->ne[0], b->ne[1], b->ne[2]);

  result->op     = GGML_OP_GET_ROWS;
  result->src[0] = a;
  result->src[1] = b;

  return result;
3876}

3878// ggml_get_rows_back

3880struct ggml_tensor * ggml_get_rows_back(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      struct ggml_tensor  * c) {
  GGML_ASSERT(ggml_is_matrix(a) && ggml_is_vector(b) && b->type == GGML_TYPE_I32)if (!(ggml_is_matrix(a) && ggml_is_vector(b) &&
 b->type == GGML_TYPE_I32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3885, "GGML_ASSERT(%s) failed", "ggml_is_matrix(a) && ggml_is_vector(b) && b->type == GGML_TYPE_I32"
);
  GGML_ASSERT(ggml_is_matrix(c) && (a->ne[0] == c->ne[0]))if (!(ggml_is_matrix(c) && (a->ne[0] == c->ne[0
]))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3886, "GGML_ASSERT(%s) failed", "ggml_is_matrix(c) && (a->ne[0] == c->ne[0])"
);

  // TODO: implement non F32 return
  //struct ggml_tensor * result = ggml_new_tensor_2d(ctx, a->type, a->ne[0], b->ne[0]);
  struct ggml_tensor * result = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, c->ne[0], c->ne[1]);

  result->op     = GGML_OP_GET_ROWS_BACK;
  result->src[0] = a;
  result->src[1] = b;

  return result;
3897}

3899// ggml_set_rows

3901struct ggml_tensor * ggml_set_rows(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      struct ggml_tensor  * c) {
  GGML_ASSERT(a->ne[0] == b->ne[0])if (!(a->ne[0] == b->ne[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3906, "GGML_ASSERT(%s) failed", "a->ne[0] == b->ne[0]"
);
  GGML_ASSERT(a->ne[2] == b->ne[2])if (!(a->ne[2] == b->ne[2])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3907, "GGML_ASSERT(%s) failed", "a->ne[2] == b->ne[2]"
);
  GGML_ASSERT(a->ne[3] == b->ne[3])if (!(a->ne[3] == b->ne[3])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3908, "GGML_ASSERT(%s) failed", "a->ne[3] == b->ne[3]"
);
  GGML_ASSERT(b->ne[1] == c->ne[0])if (!(b->ne[1] == c->ne[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3909, "GGML_ASSERT(%s) failed", "b->ne[1] == c->ne[0]"
);
  GGML_ASSERT(b->ne[2] % c->ne[1] == 0)if (!(b->ne[2] % c->ne[1] == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3910, "GGML_ASSERT(%s) failed", "b->ne[2] % c->ne[1] == 0"
);
  GGML_ASSERT(b->ne[3] % c->ne[2] == 0)if (!(b->ne[3] % c->ne[2] == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3911, "GGML_ASSERT(%s) failed", "b->ne[3] % c->ne[2] == 0"
);
  GGML_ASSERT(c->ne[3] == 1)if (!(c->ne[3] == 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3912, "GGML_ASSERT(%s) failed", "c->ne[3] == 1");
  GGML_ASSERT(b->type == GGML_TYPE_F32)if (!(b->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3913, "GGML_ASSERT(%s) failed", "b->type == GGML_TYPE_F32"
);
  GGML_ASSERT(c->type == GGML_TYPE_I64 || c->type == GGML_TYPE_I32)if (!(c->type == GGML_TYPE_I64 || c->type == GGML_TYPE_I32
)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3914, "GGML_ASSERT(%s) failed", "c->type == GGML_TYPE_I64 || c->type == GGML_TYPE_I32"
);

  GGML_ASSERT(ggml_is_contiguous_rows(a))if (!(ggml_is_contiguous_rows(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3916, "GGML_ASSERT(%s) failed", "ggml_is_contiguous_rows(a)"
);
  GGML_ASSERT(ggml_is_contiguous_rows(b))if (!(ggml_is_contiguous_rows(b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3917, "GGML_ASSERT(%s) failed", "ggml_is_contiguous_rows(b)"
);

  struct ggml_tensor * result = ggml_view_tensor(ctx, a);

  result->op     = GGML_OP_SET_ROWS;
  result->src[0] = b;
  result->src[1] = c;
  result->src[2] = a; // note: order is weird due to legacy reasons (https://github.com/ggml-org/llama.cpp/pull/16063#discussion_r2385795931)

  return result;
3927}

3929// ggml_diag

3931struct ggml_tensor * ggml_diag(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  GGML_ASSERT(a->ne[1] == 1)if (!(a->ne[1] == 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 3934, "GGML_ASSERT(%s) failed", "a->ne[1] == 1");

  const int64_t ne[4] = { a->ne[0], a->ne[0], a->ne[2], a->ne[3] };
  struct ggml_tensor * result = ggml_new_tensor(ctx, a->type, 4, ne);

  result->op     = GGML_OP_DIAG;
  result->src[0] = a;

  return result;
3943}

3945// ggml_diag_mask_inf

3947static struct ggml_tensor * ggml_diag_mask_inf_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   n_past,
      bool_Bool                  inplace) {
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  int32_t params[] = { n_past };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_DIAG_MASK_INF;
  result->src[0] = a;

  return result;
3961}

3963struct ggml_tensor * ggml_diag_mask_inf(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   n_past) {
  return ggml_diag_mask_inf_impl(ctx, a, n_past, false0);
3968}

3970struct ggml_tensor * ggml_diag_mask_inf_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   n_past) {
  return ggml_diag_mask_inf_impl(ctx, a, n_past, true1);
3975}

3977// ggml_diag_mask_zero

3979static struct ggml_tensor * ggml_diag_mask_zero_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   n_past,
      bool_Bool                  inplace) {
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  int32_t params[] = { n_past };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_DIAG_MASK_ZERO;
  result->src[0] = a;

  return result;
3993}

3995struct ggml_tensor * ggml_diag_mask_zero(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   n_past) {
  return ggml_diag_mask_zero_impl(ctx, a, n_past, false0);
4000}

4002struct ggml_tensor * ggml_diag_mask_zero_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   n_past) {
  return ggml_diag_mask_zero_impl(ctx, a, n_past, true1);
4007}

4009// ggml_soft_max

4011static struct ggml_tensor * ggml_soft_max_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * mask,
      float                 scale,
      float                 max_bias,
      bool_Bool                  inplace) {
  GGML_ASSERT(ggml_is_contiguous(a))if (!(ggml_is_contiguous(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4018, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(a)");

  if (mask) {
      GGML_ASSERT(mask->type == GGML_TYPE_F16 || mask->type == GGML_TYPE_F32)if (!(mask->type == GGML_TYPE_F16 || mask->type == GGML_TYPE_F32
)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4021, "GGML_ASSERT(%s) failed", "mask->type == GGML_TYPE_F16 || mask->type == GGML_TYPE_F32"
);
      GGML_ASSERT(ggml_is_contiguous(mask))if (!(ggml_is_contiguous(mask))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4022, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(mask)");
      GGML_ASSERT(mask->ne[0] == a->ne[0])if (!(mask->ne[0] == a->ne[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4023, "GGML_ASSERT(%s) failed", "mask->ne[0] == a->ne[0]"
);
      GGML_ASSERT(mask->ne[1] >= a->ne[1])if (!(mask->ne[1] >= a->ne[1])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4024, "GGML_ASSERT(%s) failed", "mask->ne[1] >= a->ne[1]"
);
      GGML_ASSERT(a->ne[2]%mask->ne[2] == 0)if (!(a->ne[2]%mask->ne[2] == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4025, "GGML_ASSERT(%s) failed", "a->ne[2]%mask->ne[2] == 0"
);
      GGML_ASSERT(a->ne[3]%mask->ne[3] == 0)if (!(a->ne[3]%mask->ne[3] == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4026, "GGML_ASSERT(%s) failed", "a->ne[3]%mask->ne[3] == 0"
);
  }

  if (max_bias > 0.0f) {
      GGML_ASSERT(mask)if (!(mask)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4030, "GGML_ASSERT(%s) failed", "mask");
  }

  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  float params[] = { scale, max_bias };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_SOFT_MAX;
  result->src[0] = a;
  result->src[1] = mask;

  return result;
4043}

4045struct ggml_tensor * ggml_soft_max(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_soft_max_impl(ctx, a, NULL((void*)0), 1.0f, 0.0f, false0);
4049}

4051struct ggml_tensor * ggml_soft_max_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a) {
  return ggml_soft_max_impl(ctx, a, NULL((void*)0), 1.0f, 0.0f, true1);
4055}

4057struct ggml_tensor * ggml_soft_max_ext(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * mask,
      float                 scale,
      float                 max_bias) {
  return ggml_soft_max_impl(ctx, a, mask, scale, max_bias, false0);
4064}

4066struct ggml_tensor * ggml_soft_max_ext_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * mask,
      float                 scale,
      float                 max_bias) {
  return ggml_soft_max_impl(ctx, a, mask, scale, max_bias, true1);
4073}

4075void ggml_soft_max_add_sinks(
      struct ggml_tensor * a,
      struct ggml_tensor * sinks) {
  if (!sinks) {
      a->src[2] = NULL((void*)0);
      return;
  }

  GGML_ASSERT(a->op == GGML_OP_SOFT_MAX)if (!(a->op == GGML_OP_SOFT_MAX)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4083, "GGML_ASSERT(%s) failed", "a->op == GGML_OP_SOFT_MAX"
);
  GGML_ASSERT(a->src[2] == NULL)if (!(a->src[2] == ((void*)0))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4084, "GGML_ASSERT(%s) failed", "a->src[2] == NULL");
  GGML_ASSERT(a->src[0]->ne[2] == sinks->ne[0])if (!(a->src[0]->ne[2] == sinks->ne[0])) ggml_abort(
"/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4085, "GGML_ASSERT(%s) failed", "a->src[0]->ne[2] == sinks->ne[0]"
);
  GGML_ASSERT(sinks->type == GGML_TYPE_F32)if (!(sinks->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4086, "GGML_ASSERT(%s) failed", "sinks->type == GGML_TYPE_F32"
);

  a->src[2] = sinks;
4089}

4091// ggml_soft_max_ext_back

4093static struct ggml_tensor * ggml_soft_max_ext_back_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      float                 scale,
      float                 max_bias,
      bool_Bool                  inplace) {
  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  result->op     = GGML_OP_SOFT_MAX_BACK;
  result->src[0] = a;
  result->src[1] = b;

  memcpy((float *) result->op_params + 0, &scale,    sizeof(float));
  memcpy((float *) result->op_params + 1, &max_bias, sizeof(float));

  return result;
4110}

4112struct ggml_tensor * ggml_soft_max_ext_back(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      float                 scale,
      float                 max_bias) {
  return ggml_soft_max_ext_back_impl(ctx, a, b, scale, max_bias, false0);
4119}

4121struct ggml_tensor * ggml_soft_max_ext_back_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      float                 scale,
      float                 max_bias) {
  return ggml_soft_max_ext_back_impl(ctx, a, b, scale, max_bias, true1);
4128}

4130// ggml_rope

4132static struct ggml_tensor * ggml_rope_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      struct ggml_tensor  * c,
      int                   n_dims,
      int                   sections[GGML_MROPE_SECTIONS4],
      int                   mode,
      int                   n_ctx_orig,
      float                 freq_base,
      float                 freq_scale,
      float                 ext_factor,
      float                 attn_factor,
      float                 beta_fast,
      float                 beta_slow,
      bool_Bool                  inplace) {
  GGML_ASSERT((mode & 1) == 0 && "mode & 1 == 1 is no longer supported")if (!((mode & 1) == 0 && "mode & 1 == 1 is no longer supported"
)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4148, "GGML_ASSERT(%s) failed", "(mode & 1) == 0 && \"mode & 1 == 1 is no longer supported\""
);

  GGML_ASSERT(ggml_is_vector(b))if (!(ggml_is_vector(b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4150, "GGML_ASSERT(%s) failed", "ggml_is_vector(b)");
  GGML_ASSERT(b->type == GGML_TYPE_I32)if (!(b->type == GGML_TYPE_I32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4151, "GGML_ASSERT(%s) failed", "b->type == GGML_TYPE_I32"
);

  bool_Bool mrope_used = mode & GGML_ROPE_TYPE_MROPE8;
  if (mrope_used) {
      GGML_ASSERT(a->ne[2] * 4 == b->ne[0])if (!(a->ne[2] * 4 == b->ne[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4155, "GGML_ASSERT(%s) failed", "a->ne[2] * 4 == b->ne[0]"
); // mrope expecting 4 position ids per token
  } else {
      GGML_ASSERT(a->ne[2] == b->ne[0])if (!(a->ne[2] == b->ne[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4157, "GGML_ASSERT(%s) failed", "a->ne[2] == b->ne[0]"
);
  }

  if (c) {
      GGML_ASSERT(c->type == GGML_TYPE_F32)if (!(c->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4161, "GGML_ASSERT(%s) failed", "c->type == GGML_TYPE_F32"
);
      GGML_ASSERT(c->ne[0] >= n_dims / 2)if (!(c->ne[0] >= n_dims / 2)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4162, "GGML_ASSERT(%s) failed", "c->ne[0] >= n_dims / 2"
);
  }

  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  int32_t params[15] = { /*n_past*/ 0, n_dims, mode, /*n_ctx*/ 0, n_ctx_orig };
  memcpy(params +  5, &freq_base,    sizeof(float));
  memcpy(params +  6, &freq_scale,   sizeof(float));
  memcpy(params +  7, &ext_factor,   sizeof(float));
  memcpy(params +  8, &attn_factor,  sizeof(float));
  memcpy(params +  9, &beta_fast,    sizeof(float));
  memcpy(params + 10, &beta_slow,    sizeof(float));
  if (mrope_used && sections) {
      memcpy(params + 11, sections,  sizeof(int32_t) * GGML_MROPE_SECTIONS4);
  } else {
      memset(params + 11, 0,         sizeof(int32_t) * GGML_MROPE_SECTIONS4);
  }
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_ROPE;
  result->src[0] = a;
  result->src[1] = b;
  result->src[2] = c;

  return result;
4187}

4189struct ggml_tensor * ggml_rope(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   n_dims,
      int                   mode) {
  return ggml_rope_impl(
      ctx, a, b, NULL((void*)0), n_dims, NULL((void*)0), mode, 0, 10000.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, false0
  );
4198}

4200struct ggml_tensor * ggml_rope_multi(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      struct ggml_tensor  * c,
      int                   n_dims,
      int                   sections[GGML_MROPE_SECTIONS4],
      int                   mode,
      int                   n_ctx_orig,
      float                 freq_base,
      float                 freq_scale,
      float                 ext_factor,
      float                 attn_factor,
      float                 beta_fast,
      float                 beta_slow) {
  return ggml_rope_impl(
      ctx, a, b, c, n_dims, sections, mode, n_ctx_orig, freq_base, freq_scale,
      ext_factor, attn_factor, beta_fast, beta_slow, false0
  );
4219}

4221struct ggml_tensor * ggml_rope_multi_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      struct ggml_tensor  * c,
      int                   n_dims,
      int                   sections[GGML_MROPE_SECTIONS4],
      int                   mode,
      int                   n_ctx_orig,
      float                 freq_base,
      float                 freq_scale,
      float                 ext_factor,
      float                 attn_factor,
      float                 beta_fast,
      float                 beta_slow) {
  return ggml_rope_impl(
      ctx, a, b, c, n_dims, sections, mode, n_ctx_orig, freq_base, freq_scale,
      ext_factor, attn_factor, beta_fast, beta_slow, true1
  );
4240}

4242struct ggml_tensor * ggml_rope_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   n_dims,
      int                   mode) {
  return ggml_rope_impl(
      ctx, a, b, NULL((void*)0), n_dims, NULL((void*)0), mode, 0, 10000.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, true1
  );
4251}

4253struct ggml_tensor * ggml_rope_ext(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      struct ggml_tensor  * c,
      int                   n_dims,
      int                   mode,
      int                   n_ctx_orig,
      float                 freq_base,
      float                 freq_scale,
      float                 ext_factor,
      float                 attn_factor,
      float                 beta_fast,
      float                 beta_slow) {
  return ggml_rope_impl(
      ctx, a, b, c, n_dims, NULL((void*)0), mode, n_ctx_orig, freq_base, freq_scale,
      ext_factor, attn_factor, beta_fast, beta_slow, false0
  );
4271}

4273struct ggml_tensor * ggml_rope_ext_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      struct ggml_tensor  * c,
      int                   n_dims,
      int                   mode,
      int                   n_ctx_orig,
      float                 freq_base,
      float                 freq_scale,
      float                 ext_factor,
      float                 attn_factor,
      float                 beta_fast,
      float                 beta_slow) {
  return ggml_rope_impl(
      ctx, a, b, c, n_dims, NULL((void*)0), mode, n_ctx_orig, freq_base, freq_scale,
      ext_factor, attn_factor, beta_fast, beta_slow, true1
  );
4291}

4293struct ggml_tensor * ggml_rope_custom(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   n_dims,
      int                   mode,
      int                   n_ctx_orig,
      float                 freq_base,
      float                 freq_scale,
      float                 ext_factor,
      float                 attn_factor,
      float                 beta_fast,
      float                 beta_slow) {
  return ggml_rope_impl(
      ctx, a, b, NULL((void*)0), n_dims, NULL((void*)0), mode, n_ctx_orig, freq_base, freq_scale,
      ext_factor, attn_factor, beta_fast, beta_slow, false0
  );
4310}

4312struct ggml_tensor * ggml_rope_custom_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   n_dims,
      int                   mode,
      int                   n_ctx_orig,
      float                 freq_base,
      float                 freq_scale,
      float                 ext_factor,
      float                 attn_factor,
      float                 beta_fast,
      float                 beta_slow) {
  return ggml_rope_impl(
      ctx, a, b, NULL((void*)0), n_dims, NULL((void*)0), mode, n_ctx_orig, freq_base, freq_scale,
      ext_factor, attn_factor, beta_fast, beta_slow, true1
  );
4329}

4331// Apparently solving `n_rot = 2pi * x * base^((2 * max_pos_emb) / n_dims)` for x, we get
4332// `corr_dim(n_rot) = n_dims * log(max_pos_emb / (n_rot * 2pi)) / (2 * log(base))`
4333static float ggml_rope_yarn_corr_dim(int n_dims, int n_ctx_orig, float n_rot, float base) {
  return n_dims * logf(n_ctx_orig / (n_rot * 2 * (float)M_PI3.14159265358979323846)) / (2 * logf(base));
4335}

4337void ggml_rope_yarn_corr_dims(
  int n_dims, int n_ctx_orig, float freq_base, float beta_fast, float beta_slow, float dims[2]
4339) {
  // start and end correction dims
  float start = floorf(ggml_rope_yarn_corr_dim(n_dims, n_ctx_orig, beta_fast, freq_base));
  float end   =  ceilf(ggml_rope_yarn_corr_dim(n_dims, n_ctx_orig, beta_slow, freq_base));
  dims[0] = MAX(0, start)((0) > (start) ? (0) : (start));
  dims[1] = MIN(n_dims - 1, end)((n_dims - 1) < (end) ? (n_dims - 1) : (end));
4345}

4347// ggml_rope_back

4349struct ggml_tensor * ggml_rope_ext_back(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      struct ggml_tensor  * c,
      int                   n_dims,
      int                   mode,
      int                   n_ctx_orig,
      float                 freq_base,
      float                 freq_scale,
      float                 ext_factor,
      float                 attn_factor,
      float                 beta_fast,
      float                 beta_slow) {
  struct ggml_tensor * result = ggml_rope_ext(
      ctx, a, b, c, n_dims, mode, n_ctx_orig, freq_base, freq_scale, ext_factor, attn_factor, beta_fast, beta_slow);
  result->op = GGML_OP_ROPE_BACK;
  return result;
4367}

4369struct ggml_tensor * ggml_rope_multi_back(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      struct ggml_tensor  * c,
      int                   n_dims,
      int                   sections[4],
      int                   mode,
      int                   n_ctx_orig,
      float                 freq_base,
      float                 freq_scale,
      float                 ext_factor,
      float                 attn_factor,
      float                 beta_fast,
      float                 beta_slow) {
  struct ggml_tensor * result = ggml_rope_multi(
      ctx, a, b, c, n_dims, sections, mode, n_ctx_orig, freq_base, freq_scale, ext_factor, attn_factor, beta_fast, beta_slow);
  result->op = GGML_OP_ROPE_BACK;
  return result;
4388}
4389// ggml_clamp

4391struct ggml_tensor * ggml_clamp(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      float                 min,
      float                 max) {
  // TODO: when implement backward, fix this:
  struct ggml_tensor * result = ggml_view_tensor(ctx, a);

  float params[] = { min, max };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_CLAMP;
  result->src[0] = a;

  return result;
4406}

4408static int64_t ggml_calc_conv_output_size(int64_t ins, int64_t ks, int s, int p, int d) {
  return (ins + 2 * p - d * (ks - 1) - 1) / s + 1;
4410}

4412// im2col: [N, IC, IH, IW] => [N, OH, OW, IC*KH*KW]
4413// a: [OC，IC, KH, KW]
4414// b: [N, IC, IH, IW]
4415// result: [N, OH, OW, IC*KH*KW]
4416struct ggml_tensor * ggml_im2col(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   s0,
      int                   s1,
      int                   p0,
      int                   p1,
      int                   d0,
      int                   d1,
      bool_Bool                  is_2D,
      enum ggml_type        dst_type) {
  if (is_2D) {
      GGML_ASSERT(a->ne[2] == b->ne[2])if (!(a->ne[2] == b->ne[2])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4429, "GGML_ASSERT(%s) failed", "a->ne[2] == b->ne[2]"
);
  } else {
      //GGML_ASSERT(b->ne[1] % a->ne[1] == 0);
      GGML_ASSERT(b->ne[1] == a->ne[1])if (!(b->ne[1] == a->ne[1])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4432, "GGML_ASSERT(%s) failed", "b->ne[1] == a->ne[1]"
);
      GGML_ASSERT(b->ne[3] == 1)if (!(b->ne[3] == 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4433, "GGML_ASSERT(%s) failed", "b->ne[3] == 1");
  }

  const int64_t OH = is_2D ? ggml_calc_conv_output_size(b->ne[1], a->ne[1], s1, p1, d1) : 0;
  const int64_t OW =         ggml_calc_conv_output_size(b->ne[0], a->ne[0], s0, p0, d0);

  GGML_ASSERT((!is_2D || OH > 0) && "b too small compared to a")if (!((!is_2D || OH > 0) && "b too small compared to a"
)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4439, "GGML_ASSERT(%s) failed", "(!is_2D || OH > 0) && \"b too small compared to a\""
);
  GGML_ASSERT((OW > 0)           && "b too small compared to a")if (!((OW > 0) && "b too small compared to a")) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4440, "GGML_ASSERT(%s) failed", "(OW > 0) && \"b too small compared to a\""
);

  const int64_t ne[4] = {
      is_2D ? (a->ne[2] * a->ne[1] * a->ne[0]) : a->ne[1] * a->ne[0],
      OW,
      is_2D ? OH : b->ne[2],
      is_2D ?      b->ne[3] : 1,
  };

  struct ggml_tensor * result = ggml_new_tensor(ctx, dst_type, 4, ne);
  int32_t params[] = { s0, s1, p0, p1, d0, d1, (is_2D ? 1 : 0) };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_IM2COL;
  result->src[0] = a;
  result->src[1] = b;

  return result;
4458}

4460struct ggml_tensor * ggml_im2col_back(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int64_t             * ne,
      int                   s0,
      int                   s1,
      int                   p0,
      int                   p1,
      int                   d0,
      int                   d1,
      bool_Bool                  is_2D) {
  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);
  int32_t params[] = { s0, s1, p0, p1, d0, d1, (is_2D ? 1 : 0) };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_IM2COL_BACK;
  result->src[0] = a;
  result->src[1] = b;

  return result;
4481}

4483// ggml_conv_1d

4485struct ggml_tensor * ggml_conv_1d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   s0,
      int                   p0,
      int                   d0) {
  struct ggml_tensor * im2col = ggml_im2col(ctx, a, b, s0, 0, p0, 0, d0, 0, false0, GGML_TYPE_F16); // [N, OL, IC * K]

  struct ggml_tensor * result =
      ggml_mul_mat(ctx,
              ggml_reshape_2d(ctx, im2col, im2col->ne[0], (im2col->ne[2] * im2col->ne[1])), // [N, OL, IC * K] => [N*OL, IC * K]
              ggml_reshape_2d(ctx, a, (a->ne[0] * a->ne[1]), a->ne[2]));                    // [OC，IC, K] => [OC, IC * K]

  result = ggml_reshape_3d(ctx, result, im2col->ne[1], a->ne[2], im2col->ne[2]); // [N, OC, OL]

  return result;
4502}

4504// ggml_conv_1d_ph

4506struct ggml_tensor* ggml_conv_1d_ph(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   s,
      int                   d) {
  return ggml_conv_1d(ctx, a, b, s, a->ne[0] / 2, d);
4513}

4515// ggml_conv_1d_dw

4517struct ggml_tensor * ggml_conv_1d_dw(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   s0,
      int                   p0,
      int                   d0) {
  struct ggml_tensor * new_b = ggml_reshape_4d(ctx, b, b->ne[0], 1, b->ne[1], b->ne[2]);

  struct ggml_tensor * im2col = ggml_im2col(ctx, a, new_b, s0, 0, p0, 0, d0, 0, false0, GGML_TYPE_F16);

  struct ggml_tensor * result = ggml_mul_mat(ctx, im2col, a);

  result = ggml_reshape_3d(ctx, result, result->ne[0], result->ne[2], 1);

  return result;
4533}

4535// ggml_conv_1d_dw_ph

4537struct ggml_tensor * ggml_conv_1d_dw_ph(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   s0,
      int                   d0) {
  return ggml_conv_1d_dw(ctx, a, b, s0, a->ne[0] / 2, d0);
4544}

4546// ggml_col2im_1d

4548struct ggml_tensor * ggml_col2im_1d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   s0,
      int                   oc,
      int                   p0) {
  GGML_ASSERT(ggml_is_matrix(a))if (!(ggml_is_matrix(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4554, "GGML_ASSERT(%s) failed", "ggml_is_matrix(a)");
  GGML_ASSERT(ggml_is_contiguous(a))if (!(ggml_is_contiguous(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4555, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(a)");
  GGML_ASSERT(a->type == GGML_TYPE_F32 || a->type == GGML_TYPE_F16 || a->type == GGML_TYPE_BF16)if (!(a->type == GGML_TYPE_F32 || a->type == GGML_TYPE_F16
 || a->type == GGML_TYPE_BF16)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4556, "GGML_ASSERT(%s) failed", "a->type == GGML_TYPE_F32 || a->type == GGML_TYPE_F16 || a->type == GGML_TYPE_BF16"
);
  GGML_ASSERT(s0 > 0)if (!(s0 > 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4557, "GGML_ASSERT(%s) failed", "s0 > 0");
  GGML_ASSERT(oc > 0)if (!(oc > 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4558, "GGML_ASSERT(%s) failed", "oc > 0");
  GGML_ASSERT(p0 >= 0)if (!(p0 >= 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4559, "GGML_ASSERT(%s) failed", "p0 >= 0");

  const int64_t K_OC = a->ne[0];
  const int64_t T_in = a->ne[1];
  const int64_t K = K_OC / oc;
  const int64_t T_out = (T_in - 1) * s0 + K - 2 * p0;

  GGML_ASSERT(K_OC == K * oc)if (!(K_OC == K * oc)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4566, "GGML_ASSERT(%s) failed", "K_OC == K * oc");  // a->ne[0] must be a whole number of oc blocks
  GGML_ASSERT(K > 0 && T_out > 0)if (!(K > 0 && T_out > 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4567, "GGML_ASSERT(%s) failed", "K > 0 && T_out > 0"
);

  const int64_t ne[4] = { T_out, oc, 1, 1 };
  struct ggml_tensor * result = ggml_new_tensor(ctx, a->type, 2, ne);

  int32_t params[] = { s0, (int32_t)oc, (int32_t)p0 };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_COL2IM_1D;
  result->src[0] = a;

  return result;
4579}

4581// ggml_conv_transpose_1d

4583static int64_t ggml_calc_conv_transpose_1d_output_size(int64_t ins, int64_t ks, int s, int p, int d) {
  return (ins - 1) * s - 2 * p + d * (ks - 1) + 1;
4585}

4587GGML_API__attribute__ ((visibility ("default"))) extern struct ggml_tensor * ggml_conv_transpose_1d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   s0,
      int                   p0,
      int                   d0) {
  GGML_ASSERT(ggml_is_matrix(b))if (!(ggml_is_matrix(b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4594, "GGML_ASSERT(%s) failed", "ggml_is_matrix(b)");
  GGML_ASSERT(a->ne[2] == b->ne[1])if (!(a->ne[2] == b->ne[1])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4595, "GGML_ASSERT(%s) failed", "a->ne[2] == b->ne[1]"
);
  GGML_ASSERT(a->ne[3] == 1)if (!(a->ne[3] == 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4596, "GGML_ASSERT(%s) failed", "a->ne[3] == 1");

  GGML_ASSERT(p0 == 0)if (!(p0 == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4598, "GGML_ASSERT(%s) failed", "p0 == 0");
  GGML_ASSERT(d0 == 1)if (!(d0 == 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4599, "GGML_ASSERT(%s) failed", "d0 == 1");

  const int64_t ne[4] = {
      ggml_calc_conv_transpose_1d_output_size(b->ne[0], a->ne[0], s0, 0 /*p0*/, 1 /*d0*/),
      a->ne[1], b->ne[2], 1,
  };
  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  int32_t params[] = { s0, p0, d0 };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_CONV_TRANSPOSE_1D;
  result->src[0] = a;
  result->src[1] = b;

  return result;
4615}

4617// ggml_conv_2d

4619// a: [OC，IC, KH, KW]
4620// b: [N, IC, IH, IW]
4621// result: [N, OC, OH, OW]
4622struct ggml_tensor * ggml_conv_2d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   s0,
      int                   s1,
      int                   p0,
      int                   p1,
      int                   d0,
      int                   d1) {
  struct ggml_tensor * im2col = ggml_im2col(ctx, a, b, s0, s1, p0, p1, d0, d1, true1, a->type); // [N, OH, OW, IC * KH * KW]

  struct ggml_tensor * result =
      ggml_mul_mat(ctx,
              ggml_reshape_2d(ctx, im2col, im2col->ne[0],  im2col->ne[3] * im2col->ne[2] * im2col->ne[1]), // [N, OH, OW, IC * KH * KW] => [N*OH*OW, IC * KH * KW]
              ggml_reshape_2d(ctx, a, (a->ne[0] * a->ne[1] * a->ne[2]),  a->ne[3]));                       // [OC，IC, KH, KW] => [OC, IC * KH * KW]

  result = ggml_reshape_4d(ctx, result, im2col->ne[1], im2col->ne[2], im2col->ne[3], a->ne[3]); // [OC, N, OH, OW]
  result = ggml_cont(ctx, ggml_permute(ctx, result, 0, 1, 3, 2)); // [N, OC, OH, OW]


  return result;
4644}

4646// a: [OC*IC, KD, KH, KW]
4647// b: [N*IC, ID, IH, IW]
4648// result: [N*OD, OH, OW, IC * KD * KH * KW]
4649struct ggml_tensor * ggml_im2col_3d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int64_t               IC,
      int                   s0, // stride width
      int                   s1, // stride height
      int                   s2, // stride depth
      int                   p0, // padding width
      int                   p1, // padding height
      int                   p2, // padding depth
      int                   d0, // dilation width
      int                   d1, // dilation height
      int                   d2, // dilation depth
      enum ggml_type        dst_type) {
  const int64_t N = b->ne[3] / IC;
  const int64_t ID = b->ne[2];
  const int64_t IH = b->ne[1];
  const int64_t IW = b->ne[0];

  const int64_t OC = a->ne[3] / IC;
  UNUSED(OC)(void)(OC);
  const int64_t KD = a->ne[2];
  const int64_t KH = a->ne[1];
  const int64_t KW = a->ne[0];
  const int64_t OD = ggml_calc_conv_output_size(ID, KD, s2, p2, d2);
  const int64_t OH = ggml_calc_conv_output_size(IH, KH, s1, p1, d1);
  const int64_t OW = ggml_calc_conv_output_size(IW, KW, s0, p0, d0);

  GGML_ASSERT((OD > 0)  && "b too small compared to a")if (!((OD > 0) && "b too small compared to a")) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4678, "GGML_ASSERT(%s) failed", "(OD > 0) && \"b too small compared to a\""
);
  GGML_ASSERT((OH > 0)  && "b too small compared to a")if (!((OH > 0) && "b too small compared to a")) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4679, "GGML_ASSERT(%s) failed", "(OH > 0) && \"b too small compared to a\""
);
  GGML_ASSERT((OW > 0)  && "b too small compared to a")if (!((OW > 0) && "b too small compared to a")) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4680, "GGML_ASSERT(%s) failed", "(OW > 0) && \"b too small compared to a\""
);


  const int64_t ne[4] = {KW*KH*KD*IC, OW, OH, OD*N};

  struct ggml_tensor * result = ggml_new_tensor(ctx, dst_type, 4, ne);
  int32_t params[] = { s0, s1, s2, p0, p1, p2, d0, d1, d2, (int32_t)IC};
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_IM2COL_3D;
  result->src[0] = a;
  result->src[1] = b;

  return result;
4694}

4696// a: [OC*IC, KD, KH, KW]
4697// b: [N*IC, ID, IH, IW]
4698// result: [N*OC, OD, OH, OW]
4699struct ggml_tensor * ggml_conv_3d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int64_t               IC,
      int                   s0, // stride width
      int                   s1, // stride height
      int                   s2, // stride depth
      int                   p0, // padding width
      int                   p1, // padding height
      int                   p2, // padding depth
      int                   d0, // dilation width
      int                   d1, // dilation height
      int                   d2  // dilation depth
      ) {
  struct ggml_tensor * im2col = ggml_im2col_3d(ctx, a, b, IC, s0, s1, s2, p0, p1, p2, d0, d1, d2, a->type); // [N*OD, OH, OW, IC * KD * KH * KW]

  int64_t OC = a->ne[3] / IC;
  int64_t N = b->ne[3] / IC;
  struct ggml_tensor * result =
      ggml_mul_mat(ctx,
              ggml_reshape_2d(ctx, im2col, im2col->ne[0], im2col->ne[3] * im2col->ne[2] * im2col->ne[1]), // [N*OD, OH, OW, IC * KD * KH * KW] => [N*OD*OH*OW, IC * KD * KH * KW]
              ggml_reshape_2d(ctx, a, (a->ne[0] * a->ne[1] * a->ne[2] * IC), OC));                          // [OC*IC, KD, KH, KW] => [OC, IC * KD * KH * KW]

  int64_t OD = im2col->ne[3] / N;
  result = ggml_reshape_4d(ctx, result, im2col->ne[1]*im2col->ne[2], OD, N, OC); // [OC, N*OD*OH*OW] => [OC, N, OD, OH*OW]
  result = ggml_cont(ctx, ggml_permute(ctx, result, 0, 1, 3, 2)); // [N, OC, OD, OH*OW]
  result = ggml_reshape_4d(ctx, result, im2col->ne[1], im2col->ne[2], OD, OC * N); // [N*OC, OD, OH, OW]

  return result;
4729}

4731// ggml_conv_2d_sk_p0

4733struct ggml_tensor * ggml_conv_2d_sk_p0(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_conv_2d(ctx, a, b, a->ne[0], a->ne[1], 0, 0, 1, 1);
4738}

4740// ggml_conv_2d_s1_ph

4742struct ggml_tensor * ggml_conv_2d_s1_ph(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  return ggml_conv_2d(ctx, a, b, 1, 1, a->ne[0] / 2, a->ne[1] / 2, 1, 1);
4747}

4749// ggml_conv_2d_dw

4751struct ggml_tensor * ggml_conv_2d_dw(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   s0,
      int                   s1,
      int                   p0,
      int                   p1,
      int                   d0,
      int                   d1) {
  struct ggml_tensor * new_a = ggml_reshape_4d(ctx, a, a->ne[0], a->ne[1], 1, a->ne[2] * a->ne[3]);
  struct ggml_tensor * im2col = ggml_im2col(ctx, new_a,
                                      ggml_reshape_4d(ctx, b, b->ne[0], b->ne[1], 1, b->ne[2] * b->ne[3]),
                                      s0, s1, p0, p1, d0, d1, true1, GGML_TYPE_F16); // [N * IC, OH, OW, KH * KW]
  struct ggml_tensor * new_b = ggml_reshape_4d(ctx, im2col, im2col->ne[0], im2col->ne[2] * im2col->ne[1], b->ne[2], b->ne[3]); // [N * IC, OH, OW, KH * KW] => [N, IC, OH * OW, KH * KW]

  new_a = ggml_reshape_4d(ctx, new_a, (new_a->ne[0] * new_a->ne[1]), new_a->ne[2],  new_a->ne[3], 1);                       // [OC，1, KH, KW] => [1, OC, 1, KH * KW]
  struct ggml_tensor * result = ggml_mul_mat(ctx, new_a, new_b);
  result = ggml_reshape_4d(ctx, result, im2col->ne[1], im2col->ne[2], b->ne[2], b->ne[3]); // [N, OC, OH, OW]

  return result;
4772}

4774// ggml_conv_2d_dw_direct

4776struct ggml_tensor * ggml_conv_2d_dw_direct(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   stride0,
      int                   stride1,
      int                   pad0,
      int                   pad1,
      int                   dilation0,
      int                   dilation1) {
  GGML_ASSERT(a->ne[2] == 1)if (!(a->ne[2] == 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4786, "GGML_ASSERT(%s) failed", "a->ne[2] == 1");
  GGML_ASSERT(a->ne[3] == b->ne[2])if (!(a->ne[3] == b->ne[2])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4787, "GGML_ASSERT(%s) failed", "a->ne[3] == b->ne[2]"
);
  int64_t ne[4];
  ne[0] = ggml_calc_conv_output_size(b->ne[0], a->ne[0], stride0, pad0, dilation0);
  ne[1] = ggml_calc_conv_output_size(b->ne[1], a->ne[1], stride1, pad1, dilation1);
  ne[2] = b->ne[2];
  ne[3] = b->ne[3];

  struct ggml_tensor * result = ggml_new_tensor(ctx, b->type, 4, ne);

  if (ggml_is_contiguous_channels(b)) {
      // Result will be permuted the same way as input (CWHN order)
      const int64_t type_size = ggml_type_size(result->type);
      GGML_ASSERT(ggml_blck_size(result->type) == 1)if (!(ggml_blck_size(result->type) == 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4799, "GGML_ASSERT(%s) failed", "ggml_blck_size(result->type) == 1"
);
      result->nb[0] = result->ne[2] * type_size;
      result->nb[1] = result->ne[0] * result->nb[0];
      result->nb[2] = type_size;
  }

  int32_t params[] = { stride0, stride1, pad0, pad1, dilation0, dilation1 };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_CONV_2D_DW;
  result->src[0] = a;
  result->src[1] = b;
  return result;
4812}

4814// ggml_conv_2d_direct

4816struct ggml_tensor * ggml_conv_2d_direct(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,   // convolution kernel [KW, KH, IC, OC]
      struct ggml_tensor  * b,   // input data [W, H, C, N]
      int                   s0,  // stride dimension 0
      int                   s1,  // stride dimension 1
      int                   p0,  // padding dimension 0
      int                   p1,  // padding dimension 1
      int                   d0,  // dilation dimension 0
      int                   d1) {// dilation dimension 1

  GGML_ASSERT(a->ne[2] == b->ne[2])if (!(a->ne[2] == b->ne[2])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4827, "GGML_ASSERT(%s) failed", "a->ne[2] == b->ne[2]"
);
  //GGML_ASSERT(a->type == b->type);

  int64_t ne[4];
  ne[0] = ggml_calc_conv_output_size(b->ne[0], a->ne[0], s0, p0, d0);
  ne[1] = ggml_calc_conv_output_size(b->ne[1], a->ne[1], s1, p1, d1);
  ne[2] = a->ne[3];
  ne[3] = b->ne[3];

  struct ggml_tensor * result = ggml_new_tensor(ctx, b->type, 4, ne);

  ggml_set_op_params_i32(result, 0, s0);
  ggml_set_op_params_i32(result, 1, s1);
  ggml_set_op_params_i32(result, 2, p0);
  ggml_set_op_params_i32(result, 3, p1);
  ggml_set_op_params_i32(result, 4, d0);
  ggml_set_op_params_i32(result, 5, d1);

  result->op = GGML_OP_CONV_2D;
  result->src[0] = a;
  result->src[1] = b;

  return result;
4850}

4852// ggml_conv_3d_direct

4854struct ggml_tensor * ggml_conv_3d_direct(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   s0,
      int                   s1,
      int                   s2,
      int                   p0,
      int                   p1,
      int                   p2,
      int                   d0,
      int                   d1,
      int                   d2,
      int                   c,
      int                   n,
      int                   oc) {

  GGML_ASSERT(a->ne[3] == (int64_t) c * oc)if (!(a->ne[3] == (int64_t) c * oc)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4871, "GGML_ASSERT(%s) failed", "a->ne[3] == (int64_t) c * oc"
);
  GGML_ASSERT(b->ne[3] == (int64_t) c * n)if (!(b->ne[3] == (int64_t) c * n)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4872, "GGML_ASSERT(%s) failed", "b->ne[3] == (int64_t) c * n"
);

  int64_t ne[4];
  ne[0] = ggml_calc_conv_output_size(b->ne[0], a->ne[0], s0, p0, d0);
  ne[1] = ggml_calc_conv_output_size(b->ne[1], a->ne[1], s1, p1, d1);
  ne[2] = ggml_calc_conv_output_size(b->ne[2], a->ne[2], s2, p2, d2);
  ne[3] = (int64_t) oc * n;

  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  ggml_set_op_params_i32(result, 0,  s0);
  ggml_set_op_params_i32(result, 1,  s1);
  ggml_set_op_params_i32(result, 2,  s2);
  ggml_set_op_params_i32(result, 3,  p0);
  ggml_set_op_params_i32(result, 4,  p1);
  ggml_set_op_params_i32(result, 5,  p2);
  ggml_set_op_params_i32(result, 6,  d0);
  ggml_set_op_params_i32(result, 7,  d1);
  ggml_set_op_params_i32(result, 8,  d2);
  ggml_set_op_params_i32(result, 9,  c);
  ggml_set_op_params_i32(result, 10, n);
  ggml_set_op_params_i32(result, 11, oc);

  result->op = GGML_OP_CONV_3D;
  result->src[0] = a;
  result->src[1] = b;

  return result;
4900}

4902// ggml_conv_transpose_2d_p0

4904static int64_t ggml_calc_conv_transpose_output_size(int64_t ins, int64_t ks, int s, int p) {
  return (ins - 1) * s - 2 * p + ks;
4906}

4908struct ggml_tensor * ggml_conv_transpose_2d_p0(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      int                   stride) {
  GGML_ASSERT(a->ne[3] == b->ne[2])if (!(a->ne[3] == b->ne[2])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4913, "GGML_ASSERT(%s) failed", "a->ne[3] == b->ne[2]"
);

  const int64_t ne[4] = {
      ggml_calc_conv_transpose_output_size(b->ne[0], a->ne[0], stride, 0 /*p0*/),
      ggml_calc_conv_transpose_output_size(b->ne[1], a->ne[1], stride, 0 /*p1*/),
      a->ne[2], b->ne[3],
  };

  struct ggml_tensor* result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  ggml_set_op_params_i32(result, 0, stride);

  result->op     = GGML_OP_CONV_TRANSPOSE_2D;
  result->src[0] = a;
  result->src[1] = b;

  return result;
4930}

4932// ggml_pool_*

4934static int64_t ggml_calc_pool_output_size(int64_t ins, int ks, int s, float p) {
  return (ins + 2 * p - ks) / s + 1;
4936}

4938// ggml_pool_1d

4940struct ggml_tensor * ggml_pool_1d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      enum ggml_op_pool     op,
      int                   k0,
      int                   s0,
      int                   p0) {
  const int64_t ne[4] = {
      ggml_calc_pool_output_size(a->ne[0], k0, s0, p0),
      a->ne[1],
      a->ne[2],
      a->ne[3],
  };
  GGML_ASSERT(ne[0] > 0)if (!(ne[0] > 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4953, "GGML_ASSERT(%s) failed", "ne[0] > 0");

  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  int32_t params[] = { op, k0, s0, p0 };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_POOL_1D;
  result->src[0] = a;

  return result;
4964}

4966// ggml_pool_2d

4968struct ggml_tensor * ggml_pool_2d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      enum ggml_op_pool     op,
      int                   k0,
      int                   k1,
      int                   s0,
      int                   s1,
      float                 p0,
      float                 p1) {
  struct ggml_tensor * result;
  const int64_t ne[4] = {
      ggml_calc_pool_output_size(a->ne[0], k0, s0, p0),
      ggml_calc_pool_output_size(a->ne[1], k1, s1, p1),
      a->ne[2],
      a->ne[3],
  };
  GGML_ASSERT(ne[0] > 0)if (!(ne[0] > 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4985, "GGML_ASSERT(%s) failed", "ne[0] > 0");
  GGML_ASSERT(ne[1] > 0)if (!(ne[1] > 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 4986, "GGML_ASSERT(%s) failed", "ne[1] > 0");

  result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  int32_t params[] = { op, k0, k1, s0, s1, p0, p1 };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_POOL_2D;
  result->src[0] = a;

  return result;
4997}

4999struct ggml_tensor * ggml_pool_2d_back(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * af,
      enum ggml_op_pool     op,
      int                   k0,
      int                   k1,
      int                   s0,
      int                   s1,
      float                 p0,
      float                 p1) {
  struct ggml_tensor * result;
  result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, af->ne);

  int32_t params[] = { op, k0, k1, s0, s1, p0, p1 };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_POOL_2D_BACK;
  result->src[0] = a;
  result->src[1] = af;

  return result;
5021}

5023// ggml_upscale / ggml_interpolate

5025static struct ggml_tensor * ggml_interpolate_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int64_t               ne0,
      int64_t               ne1,
      int64_t               ne2,
      int64_t               ne3,
      uint32_t              mode) {
  GGML_ASSERT((mode & 0xFF) < GGML_SCALE_MODE_COUNT)if (!((mode & 0xFF) < GGML_SCALE_MODE_COUNT)) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5033, "GGML_ASSERT(%s) failed", "(mode & 0xFF) < GGML_SCALE_MODE_COUNT"
);
  // TODO: implement antialias for modes other than bilinear
  GGML_ASSERT(!(mode & GGML_SCALE_FLAG_ANTIALIAS) || (mode & 0xFF) == GGML_SCALE_MODE_BILINEAR)if (!(!(mode & GGML_SCALE_FLAG_ANTIALIAS) || (mode & 0xFF
) == GGML_SCALE_MODE_BILINEAR)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5035, "GGML_ASSERT(%s) failed", "!(mode & GGML_SCALE_FLAG_ANTIALIAS) || (mode & 0xFF) == GGML_SCALE_MODE_BILINEAR"
);
  GGML_ASSERT(a->type == GGML_TYPE_F32)if (!(a->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5036, "GGML_ASSERT(%s) failed", "a->type == GGML_TYPE_F32"
);

  struct ggml_tensor * result = ggml_new_tensor_4d(ctx, a->type, ne0, ne1, ne2, ne3);

  ggml_set_op_params_i32(result, 0, (int32_t)mode);

  result->op     = GGML_OP_UPSCALE;
  result->src[0] = a;

  return result;
5046}

5048struct ggml_tensor * ggml_upscale(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   scale_factor,
      enum ggml_scale_mode  mode) {
  GGML_ASSERT(scale_factor > 1)if (!(scale_factor > 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5053, "GGML_ASSERT(%s) failed", "scale_factor > 1");
  return ggml_interpolate_impl(ctx, a, a->ne[0] * scale_factor, a->ne[1] * scale_factor, a->ne[2], a->ne[3], mode);
5055}

5057struct ggml_tensor * ggml_upscale_ext(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   ne0,
      int                   ne1,
      int                   ne2,
      int                   ne3,
      enum ggml_scale_mode  mode) {
  return ggml_interpolate_impl(ctx, a, ne0, ne1, ne2, ne3, mode);
5066}

5068struct ggml_tensor * ggml_interpolate(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int64_t               ne0,
      int64_t               ne1,
      int64_t               ne2,
      int64_t               ne3,
      uint32_t              mode) {
  return ggml_interpolate_impl(ctx, a, ne0, ne1, ne2, ne3, mode);
5077}

5079// ggml_pad

5081struct ggml_tensor * ggml_pad(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   p0,
      int                   p1,
      int                   p2,
      int                   p3) {
  return ggml_pad_ext(ctx, a, 0, p0, 0, p1, 0, p2, 0, p3);
5089}

5091// ggml_pad_circular

5093struct ggml_tensor * ggml_pad_circular(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   p0,
      int                   p1,
      int                   p2,
      int                   p3) {
  return ggml_pad_ext_circular(ctx, a, 0, p0, 0, p1, 0, p2, 0, p3);
5101}

5103struct ggml_tensor * ggml_pad_ext(
          struct ggml_context * ctx,
          struct ggml_tensor  * a,
          int                  lp0,
          int                  rp0,
          int                  lp1,
          int                  rp1,
          int                  lp2,
          int                  rp2,
          int                  lp3,
          int                  rp3
          ) {
  struct ggml_tensor * result = ggml_new_tensor_4d(ctx, a->type,
          a->ne[0] + lp0 + rp0,
          a->ne[1] + lp1 + rp1,
          a->ne[2] + lp2 + rp2,
          a->ne[3] + lp3 + rp3);

  ggml_set_op_params_i32(result, 0, lp0);
  ggml_set_op_params_i32(result, 1, rp0);
  ggml_set_op_params_i32(result, 2, lp1);
  ggml_set_op_params_i32(result, 3, rp1);
  ggml_set_op_params_i32(result, 4, lp2);
  ggml_set_op_params_i32(result, 5, rp2);
  ggml_set_op_params_i32(result, 6, lp3);
  ggml_set_op_params_i32(result, 7, rp3);
  ggml_set_op_params_i32(result, 8, 0); // not circular by default


  result->op     = GGML_OP_PAD;
  result->src[0] = a;

  return result;
5136}

5138// ggml_pad_ext_circular

5140struct ggml_tensor * ggml_pad_ext_circular(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                  lp0,
      int                  rp0,
      int                  lp1,
      int                  rp1,
      int                  lp2,
      int                  rp2,
      int                  lp3,
      int                  rp3
      ) {
  struct ggml_tensor * result = ggml_pad_ext(ctx, a, lp0, rp0, lp1, rp1, lp2, rp2, lp3, rp3);
  ggml_set_op_params_i32(result, 8, 1); // circular
  return result;
5155}

5157// ggml_pad_reflect_1d

5159struct ggml_tensor * ggml_pad_reflect_1d(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   p0,
      int                   p1) {
  GGML_ASSERT(p0 >= 0)if (!(p0 >= 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5164, "GGML_ASSERT(%s) failed", "p0 >= 0");
  GGML_ASSERT(p1 >= 0)if (!(p1 >= 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5165, "GGML_ASSERT(%s) failed", "p1 >= 0");

  GGML_ASSERT(p0 < a->ne[0])if (!(p0 < a->ne[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5167, "GGML_ASSERT(%s) failed", "p0 < a->ne[0]"); // padding length on each size must be less than the
  GGML_ASSERT(p1 < a->ne[0])if (!(p1 < a->ne[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5168, "GGML_ASSERT(%s) failed", "p1 < a->ne[0]"); // existing length of the dimension being padded

  GGML_ASSERT(ggml_is_contiguous(a))if (!(ggml_is_contiguous(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5170, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(a)");
  GGML_ASSERT(a->type == GGML_TYPE_F32)if (!(a->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5171, "GGML_ASSERT(%s) failed", "a->type == GGML_TYPE_F32"
);

  struct ggml_tensor * result = ggml_new_tensor_4d(ctx, a->type,
          a->ne[0] + p0 + p1,
          a->ne[1],
          a->ne[2],
          a->ne[3]);

  int32_t params[] = { p0, p1 };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_PAD_REFLECT_1D;
  result->src[0] = a;

  return result;
5186}

5188// ggml_roll

5190struct ggml_tensor * ggml_roll(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   shift0,
      int                   shift1,
      int                   shift2,
      int                   shift3) {
  GGML_ASSERT(a->nb[0] == ggml_type_size(a->type))if (!(a->nb[0] == ggml_type_size(a->type))) ggml_abort(
"/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5197, "GGML_ASSERT(%s) failed", "a->nb[0] == ggml_type_size(a->type)"
);
  GGML_ASSERT(abs(shift0) < a->ne[0])if (!(abs(shift0) < a->ne[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5198, "GGML_ASSERT(%s) failed", "abs(shift0) < a->ne[0]"
);
  GGML_ASSERT(abs(shift1) < a->ne[1])if (!(abs(shift1) < a->ne[1])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5199, "GGML_ASSERT(%s) failed", "abs(shift1) < a->ne[1]"
);
  GGML_ASSERT(abs(shift2) < a->ne[2])if (!(abs(shift2) < a->ne[2])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5200, "GGML_ASSERT(%s) failed", "abs(shift2) < a->ne[2]"
);
  GGML_ASSERT(abs(shift3) < a->ne[3])if (!(abs(shift3) < a->ne[3])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5201, "GGML_ASSERT(%s) failed", "abs(shift3) < a->ne[3]"
);

  struct ggml_tensor * result = ggml_dup_tensor(ctx, a);

  ggml_set_op_params_i32(result, 0, shift0);
  ggml_set_op_params_i32(result, 1, shift1);
  ggml_set_op_params_i32(result, 2, shift2);
  ggml_set_op_params_i32(result, 3, shift3);

  result->op     = GGML_OP_ROLL;
  result->src[0] = a;

  return result;
5214}

5216// ggml_timestep_embedding

5218struct ggml_tensor * ggml_timestep_embedding(
      struct ggml_context * ctx,
      struct ggml_tensor  * timesteps,
      int                   dim,
      int                   max_period) {

  struct ggml_tensor * result = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, dim, timesteps->ne[0]);

  ggml_set_op_params_i32(result, 0, dim);
  ggml_set_op_params_i32(result, 1, max_period);

  result->op     = GGML_OP_TIMESTEP_EMBEDDING;
  result->src[0] = timesteps;

  return result;
5233}

5235// ggml_tri

5237struct ggml_tensor * ggml_tri(
  struct ggml_context * ctx,
  struct ggml_tensor  * a,
  enum ggml_tri_type    type) {
  GGML_ASSERT(a->type == GGML_TYPE_F32)if (!(a->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5241, "GGML_ASSERT(%s) failed", "a->type == GGML_TYPE_F32"
);

  GGML_ASSERT(ggml_is_contiguous(a))if (!(ggml_is_contiguous(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5243, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(a)");
  GGML_ASSERT(a->ne[0] == a->ne[1])if (!(a->ne[0] == a->ne[1])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5244, "GGML_ASSERT(%s) failed", "a->ne[0] == a->ne[1]"
);

  struct ggml_tensor * result = ggml_dup_tensor(ctx, a);

  ggml_set_op_params_i32(result, 0, type);

  result->op = GGML_OP_TRI;
  result->src[0] = a;

  return result;
5254}

5256// ggml_fill

5258static struct ggml_tensor * ggml_fill_impl(
  struct ggml_context * ctx,
  struct ggml_tensor  * a,
  float                 c,
  bool_Bool                  inplace) {
  GGML_ASSERT(a->type == GGML_TYPE_F32 || a->type == GGML_TYPE_F16)if (!(a->type == GGML_TYPE_F32 || a->type == GGML_TYPE_F16
)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5263, "GGML_ASSERT(%s) failed", "a->type == GGML_TYPE_F32 || a->type == GGML_TYPE_F16"
);
  GGML_ASSERT(ggml_is_contiguous(a))if (!(ggml_is_contiguous(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5264, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(a)");

  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  ggml_set_op_params_f32(result, 0, c);

  result->op = GGML_OP_FILL;
  result->src[0] = a;

  return result;
5274}

5276struct ggml_tensor * ggml_fill(
  struct ggml_context * ctx,
  struct ggml_tensor  * a,
  float                 c) {
  return ggml_fill_impl(ctx, a, c, false0);
5281}

5283struct ggml_tensor * ggml_fill_inplace(
  struct ggml_context * ctx,
  struct ggml_tensor  * a,
  float                 c) {
  return ggml_fill_impl(ctx, a, c, true1);
5288}

5290// ggml_argsort

5292struct ggml_tensor * ggml_argsort(
      struct ggml_context  * ctx,
      struct ggml_tensor   * a,
      enum ggml_sort_order   order) {
  GGML_ASSERT(a->ne[0] <= INT32_MAX)if (!(a->ne[0] <= (2147483647))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5296, "GGML_ASSERT(%s) failed", "a->ne[0] <= INT32_MAX"
);

  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_I32, GGML_MAX_DIMS4, a->ne);

  ggml_set_op_params_i32(result, 0, (int32_t) order);

  result->op     = GGML_OP_ARGSORT;
  result->src[0] = a;

  return result;
5306}

5308// ggml_argsort_top_k

5310struct ggml_tensor * ggml_argsort_top_k(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   k) {
  GGML_ASSERT(a->ne[0] >= k)if (!(a->ne[0] >= k)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5314, "GGML_ASSERT(%s) failed", "a->ne[0] >= k");

  struct ggml_tensor * result = ggml_argsort(ctx, a, GGML_SORT_ORDER_DESC);

  result = ggml_view_4d(ctx, result,
              k, result->ne[1], result->ne[2], result->ne[3],
                 result->nb[1], result->nb[2], result->nb[3],
              0);

  return result;
5324}

5326// ggml_top_k

5328struct ggml_tensor * ggml_top_k(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   k) {
  GGML_ASSERT(a->ne[0] >= k)if (!(a->ne[0] >= k)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5332, "GGML_ASSERT(%s) failed", "a->ne[0] >= k");

  struct ggml_tensor * result = ggml_new_tensor_4d(ctx, GGML_TYPE_I32, k, a->ne[1], a->ne[2], a->ne[3]);

  result->op     = GGML_OP_TOP_K;
  result->src[0] = a;

  return result;
5340}

5342// ggml_arange

5344struct ggml_tensor * ggml_arange(
      struct ggml_context * ctx,
      float                 start,
      float                 stop,
      float                 step) {
  GGML_ASSERT(stop > start)if (!(stop > start)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5349, "GGML_ASSERT(%s) failed", "stop > start");

  const int64_t steps = (int64_t) ceilf((stop - start) / step);

  struct ggml_tensor * result = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, steps);

  ggml_set_op_params_f32(result, 0, start);
  ggml_set_op_params_f32(result, 1, stop);
  ggml_set_op_params_f32(result, 2, step);

  result->op = GGML_OP_ARANGE;

  return result;
5362}

5364// ggml_flash_attn_ext

5366struct ggml_tensor * ggml_flash_attn_ext(
      struct ggml_context * ctx,
      struct ggml_tensor  * q,
      struct ggml_tensor  * k,
      struct ggml_tensor  * v,
      struct ggml_tensor  * mask,
      float                 scale,
      float                 max_bias,
      float                 logit_softcap) {
  GGML_ASSERT(ggml_can_mul_mat(k, q))if (!(ggml_can_mul_mat(k, q))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5375, "GGML_ASSERT(%s) failed", "ggml_can_mul_mat(k, q)");
  // TODO: check if vT can be multiplied by (k*qT)

  GGML_ASSERT(q->ne[3] == k->ne[3])if (!(q->ne[3] == k->ne[3])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5378, "GGML_ASSERT(%s) failed", "q->ne[3] == k->ne[3]"
);
  GGML_ASSERT(q->ne[3] == v->ne[3])if (!(q->ne[3] == v->ne[3])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5379, "GGML_ASSERT(%s) failed", "q->ne[3] == v->ne[3]"
);

  if (mask) {
      GGML_ASSERT(mask->type == GGML_TYPE_F16)if (!(mask->type == GGML_TYPE_F16)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5382, "GGML_ASSERT(%s) failed", "mask->type == GGML_TYPE_F16"
);
      GGML_ASSERT(ggml_is_contiguous(mask))if (!(ggml_is_contiguous(mask))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5383, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(mask)");
      //GGML_ASSERT(ggml_can_repeat_rows(mask, qk));

      GGML_ASSERT(q->ne[2] % mask->ne[2] == 0)if (!(q->ne[2] % mask->ne[2] == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5386, "GGML_ASSERT(%s) failed", "q->ne[2] % mask->ne[2] == 0"
);
      GGML_ASSERT(q->ne[3] % mask->ne[3] == 0)if (!(q->ne[3] % mask->ne[3] == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5387, "GGML_ASSERT(%s) failed", "q->ne[3] % mask->ne[3] == 0"
);
  }

  if (max_bias > 0.0f) {
      GGML_ASSERT(mask)if (!(mask)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5391, "GGML_ASSERT(%s) failed", "mask");
  }

  // permute(0, 2, 1, 3)
  int64_t ne[4] = { v->ne[0], q->ne[2], q->ne[1], q->ne[3] };
  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  float params[] = { scale, max_bias, logit_softcap };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_FLASH_ATTN_EXT;
  result->src[0] = q;
  result->src[1] = k;
  result->src[2] = v;
  result->src[3] = mask;

  return result;
5408}

5410void ggml_flash_attn_ext_set_prec(
      struct ggml_tensor * a,
      enum ggml_prec       prec) {
  GGML_ASSERT(a->op == GGML_OP_FLASH_ATTN_EXT)if (!(a->op == GGML_OP_FLASH_ATTN_EXT)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5413, "GGML_ASSERT(%s) failed", "a->op == GGML_OP_FLASH_ATTN_EXT"
);

  const int32_t prec_i32 = (int32_t) prec;

  ggml_set_op_params_i32(a, 3, prec_i32); // scale is on first pos, max_bias on second
5418}

5420enum ggml_prec ggml_flash_attn_ext_get_prec(
      const struct ggml_tensor * a) {
  GGML_ASSERT(a->op == GGML_OP_FLASH_ATTN_EXT)if (!(a->op == GGML_OP_FLASH_ATTN_EXT)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5422, "GGML_ASSERT(%s) failed", "a->op == GGML_OP_FLASH_ATTN_EXT"
);

  const int32_t prec_i32 = ggml_get_op_params_i32(a, 3);

  return (enum ggml_prec) prec_i32;
5427}

5429void ggml_flash_attn_ext_add_sinks(
      struct ggml_tensor * a,
      struct ggml_tensor * sinks) {
  if (!sinks) {
      a->src[4] = NULL((void*)0);
      return;
  }

  GGML_ASSERT(a->op == GGML_OP_FLASH_ATTN_EXT)if (!(a->op == GGML_OP_FLASH_ATTN_EXT)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5437, "GGML_ASSERT(%s) failed", "a->op == GGML_OP_FLASH_ATTN_EXT"
);
  GGML_ASSERT(a->src[4] == NULL)if (!(a->src[4] == ((void*)0))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5438, "GGML_ASSERT(%s) failed", "a->src[4] == NULL");
  GGML_ASSERT(a->src[0]->ne[2] == sinks->ne[0])if (!(a->src[0]->ne[2] == sinks->ne[0])) ggml_abort(
"/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5439, "GGML_ASSERT(%s) failed", "a->src[0]->ne[2] == sinks->ne[0]"
);
  GGML_ASSERT(sinks->type == GGML_TYPE_F32)if (!(sinks->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5440, "GGML_ASSERT(%s) failed", "sinks->type == GGML_TYPE_F32"
);

  a->src[4] = sinks;
5443}

5445// ggml_flash_attn_back

5447struct ggml_tensor * ggml_flash_attn_back(
      struct ggml_context * ctx,
      struct ggml_tensor  * q,
      struct ggml_tensor  * k,
      struct ggml_tensor  * v,
      struct ggml_tensor  * d,
      bool_Bool                  masked) {
  GGML_ABORT("TODO: adapt to ggml_flash_attn_ext() changes")ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5454, "TODO: adapt to ggml_flash_attn_ext() changes");

  GGML_ASSERT(ggml_can_mul_mat(k, q))if (!(ggml_can_mul_mat(k, q))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5456, "GGML_ASSERT(%s) failed", "ggml_can_mul_mat(k, q)");
  // TODO: check if vT can be multiplied by (k*qT)

  // d shape [D,N,ne2,ne3]
  // q shape [D,N,ne2,ne3]
  // k shape [D,M,kvne2,ne3]
  // v shape [M,D,kvne2,ne3]

  const int64_t     D = q->ne[0];
  const int64_t     N = q->ne[1];
  const int64_t     M = k->ne[1];
  const int64_t   ne2 = q->ne[2];
  const int64_t   ne3 = q->ne[3];
  const int64_t kvne2 = k->ne[2];

  GGML_ASSERT(k->ne[0] == D)if (!(k->ne[0] == D)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5471, "GGML_ASSERT(%s) failed", "k->ne[0] == D");
  GGML_ASSERT(v->ne[0] == M)if (!(v->ne[0] == M)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5472, "GGML_ASSERT(%s) failed", "v->ne[0] == M");
  GGML_ASSERT(v->ne[1] == D)if (!(v->ne[1] == D)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5473, "GGML_ASSERT(%s) failed", "v->ne[1] == D");
  GGML_ASSERT(d->ne[0] == D)if (!(d->ne[0] == D)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5474, "GGML_ASSERT(%s) failed", "d->ne[0] == D");
  GGML_ASSERT(d->ne[1] == N)if (!(d->ne[1] == N)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5475, "GGML_ASSERT(%s) failed", "d->ne[1] == N");
  GGML_ASSERT(k->ne[2] == kvne2)if (!(k->ne[2] == kvne2)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5476, "GGML_ASSERT(%s) failed", "k->ne[2] == kvne2");
  GGML_ASSERT(k->ne[3] == ne3)if (!(k->ne[3] == ne3)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5477, "GGML_ASSERT(%s) failed", "k->ne[3] == ne3");
  GGML_ASSERT(v->ne[2] == kvne2)if (!(v->ne[2] == kvne2)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5478, "GGML_ASSERT(%s) failed", "v->ne[2] == kvne2");
  GGML_ASSERT(v->ne[3] == ne3)if (!(v->ne[3] == ne3)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5479, "GGML_ASSERT(%s) failed", "v->ne[3] == ne3");
  GGML_ASSERT(d->ne[2] == ne2)if (!(d->ne[2] == ne2)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5480, "GGML_ASSERT(%s) failed", "d->ne[2] == ne2");
  GGML_ASSERT(d->ne[3] == ne3)if (!(d->ne[3] == ne3)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5481, "GGML_ASSERT(%s) failed", "d->ne[3] == ne3");

  GGML_ASSERT(ne2 % kvne2 == 0)if (!(ne2 % kvne2 == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5483, "GGML_ASSERT(%s) failed", "ne2 % kvne2 == 0");

  // store gradients of q, k and v as continuous tensors concatenated in result.
  // note: v and gradv are actually transposed, i.e. v->ne[0] != D.
  const int64_t elem_q = ggml_nelements(q);
  const int64_t elem_k = ggml_nelements(k);
  const int64_t elem_v = ggml_nelements(v);

  enum ggml_type result_type = GGML_TYPE_F32;
  GGML_ASSERT(ggml_blck_size(result_type) == 1)if (!(ggml_blck_size(result_type) == 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5492, "GGML_ASSERT(%s) failed", "ggml_blck_size(result_type) == 1"
);
  const size_t tsize = ggml_type_size(result_type);

  const size_t offs_q = 0;
  const size_t offs_k = offs_q + GGML_PAD(elem_q * tsize, GGML_MEM_ALIGN)(((elem_q * tsize) + (16) - 1) & ~((16) - 1));
  const size_t offs_v = offs_k + GGML_PAD(elem_k * tsize, GGML_MEM_ALIGN)(((elem_k * tsize) + (16) - 1) & ~((16) - 1));
  const size_t end    = offs_v + GGML_PAD(elem_v * tsize, GGML_MEM_ALIGN)(((elem_v * tsize) + (16) - 1) & ~((16) - 1));

  const size_t nelements = (end + tsize - 1)/tsize;

  struct ggml_tensor * result = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, nelements);

  int32_t masked_i = masked ? 1 : 0;
  ggml_set_op_params(result, &masked_i, sizeof(masked_i));

  result->op     = GGML_OP_FLASH_ATTN_BACK;
  result->src[0] = q;
  result->src[1] = k;
  result->src[2] = v;
  result->src[3] = d;

  return result;
5514}

5516// ggml_ssm_conv

5518struct ggml_tensor * ggml_ssm_conv(
      struct ggml_context * ctx,
      struct ggml_tensor  * sx,
      struct ggml_tensor  * c) {
  GGML_ASSERT(ggml_is_3d(sx))if (!(ggml_is_3d(sx))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5522, "GGML_ASSERT(%s) failed", "ggml_is_3d(sx)");
  GGML_ASSERT(ggml_is_matrix(c))if (!(ggml_is_matrix(c))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5523, "GGML_ASSERT(%s) failed", "ggml_is_matrix(c)");

  const int64_t d_conv  = c->ne[0];
  const int64_t d_inner = c->ne[1];
  const int64_t n_t     = sx->ne[0] - d_conv + 1; // tokens per sequence
  const int64_t n_s     = sx->ne[2];

  // TODO: maybe support other strides than 1?
  GGML_ASSERT(sx->ne[0] == d_conv - 1 + n_t)if (!(sx->ne[0] == d_conv - 1 + n_t)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5531, "GGML_ASSERT(%s) failed", "sx->ne[0] == d_conv - 1 + n_t"
);
  GGML_ASSERT(sx->ne[1] == d_inner)if (!(sx->ne[1] == d_inner)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5532, "GGML_ASSERT(%s) failed", "sx->ne[1] == d_inner");
  GGML_ASSERT(n_t >= 0)if (!(n_t >= 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5533, "GGML_ASSERT(%s) failed", "n_t >= 0");

  struct ggml_tensor * result = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, d_inner, n_t, n_s);

  result->op     = GGML_OP_SSM_CONV;
  result->src[0] = sx;
  result->src[1] = c;

  return result;
5542}

5544// ggml_ssm_scan

5546struct ggml_tensor * ggml_ssm_scan(
      struct ggml_context * ctx,
      struct ggml_tensor  * s,
      struct ggml_tensor  * x,
      struct ggml_tensor  * dt,
      struct ggml_tensor  * A,
      struct ggml_tensor  * B,
      struct ggml_tensor  * C,
      struct ggml_tensor  * ids) {
  GGML_ASSERT(ggml_is_contiguous(s))if (!(ggml_is_contiguous(s))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5555, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(s)");
  GGML_ASSERT(ggml_is_contiguous(dt))if (!(ggml_is_contiguous(dt))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5556, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(dt)");
  GGML_ASSERT(ggml_is_contiguous(A))if (!(ggml_is_contiguous(A))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5557, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(A)");
  GGML_ASSERT(x->nb[0] == ggml_type_size(x->type))if (!(x->nb[0] == ggml_type_size(x->type))) ggml_abort(
"/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5558, "GGML_ASSERT(%s) failed", "x->nb[0] == ggml_type_size(x->type)"
);
  GGML_ASSERT(B->nb[0] == ggml_type_size(B->type))if (!(B->nb[0] == ggml_type_size(B->type))) ggml_abort(
"/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5559, "GGML_ASSERT(%s) failed", "B->nb[0] == ggml_type_size(B->type)"
);
  GGML_ASSERT(C->nb[0] == ggml_type_size(C->type))if (!(C->nb[0] == ggml_type_size(C->type))) ggml_abort(
"/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5560, "GGML_ASSERT(%s) failed", "C->nb[0] == ggml_type_size(C->type)"
);
  GGML_ASSERT(x->nb[1] == x->ne[0]*x->nb[0])if (!(x->nb[1] == x->ne[0]*x->nb[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5561, "GGML_ASSERT(%s) failed", "x->nb[1] == x->ne[0]*x->nb[0]"
);
  GGML_ASSERT(B->nb[1] == B->ne[0]*B->nb[0])if (!(B->nb[1] == B->ne[0]*B->nb[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5562, "GGML_ASSERT(%s) failed", "B->nb[1] == B->ne[0]*B->nb[0]"
);
  GGML_ASSERT(C->nb[1] == C->ne[0]*C->nb[0])if (!(C->nb[1] == C->ne[0]*C->nb[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5563, "GGML_ASSERT(%s) failed", "C->nb[1] == C->ne[0]*C->nb[0]"
);
  GGML_ASSERT(ggml_are_same_shape(B, C))if (!(ggml_are_same_shape(B, C))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5564, "GGML_ASSERT(%s) failed", "ggml_are_same_shape(B, C)"
);
  GGML_ASSERT(ids->type == GGML_TYPE_I32)if (!(ids->type == GGML_TYPE_I32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5565, "GGML_ASSERT(%s) failed", "ids->type == GGML_TYPE_I32"
);

  {
      const int64_t d_state      = s->ne[0];
      const int64_t head_dim     = x->ne[0];
      const int64_t n_head       = x->ne[1];
      const int64_t n_seq_tokens = x->ne[2];
      const int64_t n_seqs       = x->ne[3];

      GGML_ASSERT(dt->ne[0] == n_head)if (!(dt->ne[0] == n_head)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5574, "GGML_ASSERT(%s) failed", "dt->ne[0] == n_head");
      GGML_ASSERT(dt->ne[1] == n_seq_tokens)if (!(dt->ne[1] == n_seq_tokens)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5575, "GGML_ASSERT(%s) failed", "dt->ne[1] == n_seq_tokens"
);
      GGML_ASSERT(dt->ne[2] == n_seqs)if (!(dt->ne[2] == n_seqs)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5576, "GGML_ASSERT(%s) failed", "dt->ne[2] == n_seqs");
      GGML_ASSERT(ggml_is_3d(dt))if (!(ggml_is_3d(dt))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5577, "GGML_ASSERT(%s) failed", "ggml_is_3d(dt)");
      GGML_ASSERT(s->ne[1] == head_dim)if (!(s->ne[1] == head_dim)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5578, "GGML_ASSERT(%s) failed", "s->ne[1] == head_dim");
      GGML_ASSERT(s->ne[2] == n_head)if (!(s->ne[2] == n_head)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5579, "GGML_ASSERT(%s) failed", "s->ne[2] == n_head");
      GGML_ASSERT(B->ne[0] == d_state)if (!(B->ne[0] == d_state)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5580, "GGML_ASSERT(%s) failed", "B->ne[0] == d_state");
      GGML_ASSERT(B->ne[2] == n_seq_tokens)if (!(B->ne[2] == n_seq_tokens)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5581, "GGML_ASSERT(%s) failed", "B->ne[2] == n_seq_tokens"
);
      GGML_ASSERT(B->ne[3] == n_seqs)if (!(B->ne[3] == n_seqs)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5582, "GGML_ASSERT(%s) failed", "B->ne[3] == n_seqs");
      GGML_ASSERT(ids->ne[0] == n_seqs)if (!(ids->ne[0] == n_seqs)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5583, "GGML_ASSERT(%s) failed", "ids->ne[0] == n_seqs");
      GGML_ASSERT(ggml_is_vector(ids))if (!(ggml_is_vector(ids))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5584, "GGML_ASSERT(%s) failed", "ggml_is_vector(ids)");
      GGML_ASSERT(A->ne[1] == n_head)if (!(A->ne[1] == n_head)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5585, "GGML_ASSERT(%s) failed", "A->ne[1] == n_head");
      GGML_ASSERT(ggml_is_matrix(A))if (!(ggml_is_matrix(A))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5586, "GGML_ASSERT(%s) failed", "ggml_is_matrix(A)");

      if (A->ne[0] != 1) {
          // Mamba-1 has more granular decay factors
          GGML_ASSERT(A->ne[0] == d_state)if (!(A->ne[0] == d_state)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5590, "GGML_ASSERT(%s) failed", "A->ne[0] == d_state");
      }
  }

  // concatenated y + ssm_states
  struct ggml_tensor * result = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, ggml_nelements(x) + s->ne[0]*s->ne[1]*s->ne[2]*ids->ne[0]);

  result->op   = GGML_OP_SSM_SCAN;
  result->src[0] = s;
  result->src[1] = x;
  result->src[2] = dt;
  result->src[3] = A;
  result->src[4] = B;
  result->src[5] = C;
  result->src[6] = ids;

  return result;
5607}

5609// ggml_win_part

5611struct ggml_tensor * ggml_win_part(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   w) {
  GGML_ASSERT(a->ne[3] == 1)if (!(a->ne[3] == 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5615, "GGML_ASSERT(%s) failed", "a->ne[3] == 1");
  GGML_ASSERT(a->type  == GGML_TYPE_F32)if (!(a->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5616, "GGML_ASSERT(%s) failed", "a->type == GGML_TYPE_F32"
);

  // padding
  const int px = (w - a->ne[1]%w)%w;
  const int py = (w - a->ne[2]%w)%w;

  const int npx = (px + a->ne[1])/w;
  const int npy = (py + a->ne[2])/w;
  const int np  = npx*npy;

  const int64_t ne[4] = { a->ne[0], w, w, np, };
  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  int32_t params[] = { npx, npy, w };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_WIN_PART;
  result->src[0] = a;

  return result;
5636}

5638// ggml_win_unpart

5640struct ggml_tensor * ggml_win_unpart(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   w0,
      int                   h0,
      int                   w) {
  GGML_ASSERT(a->type == GGML_TYPE_F32)if (!(a->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5646, "GGML_ASSERT(%s) failed", "a->type == GGML_TYPE_F32"
);

  const int64_t ne[4] = { a->ne[0], w0, h0, 1, };
  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 3, ne);

  int32_t params[] = { w };
  ggml_set_op_params(result, params, sizeof(params));

  result->op     = GGML_OP_WIN_UNPART;
  result->src[0] = a;

  return result;
5658}

5660// ggml_get_rel_pos

5662struct ggml_tensor * ggml_get_rel_pos(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      int                   qh,
      int                   kh) {
  GGML_ASSERT(qh == kh)if (!(qh == kh)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5667, "GGML_ASSERT(%s) failed", "qh == kh");
  GGML_ASSERT(2*MAX(qh, kh) - 1 == a->ne[1])if (!(2*((qh) > (kh) ? (qh) : (kh)) - 1 == a->ne[1])) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5668, "GGML_ASSERT(%s) failed", "2*MAX(qh, kh) - 1 == a->ne[1]"
);

  const int64_t ne[4] = { a->ne[0], kh, qh, 1, };
  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F16, 3, ne);

  result->op     = GGML_OP_GET_REL_POS;
  result->src[0] = a;

  return result;
5677}

5679// ggml_add_rel_pos

5681static struct ggml_tensor * ggml_add_rel_pos_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * pw,
      struct ggml_tensor  * ph,
      bool_Bool                  inplace) {
  GGML_ASSERT(ggml_are_same_shape(pw, ph))if (!(ggml_are_same_shape(pw, ph))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5687, "GGML_ASSERT(%s) failed", "ggml_are_same_shape(pw, ph)"
);
  GGML_ASSERT(ggml_is_contiguous(a))if (!(ggml_is_contiguous(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5688, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(a)");
  GGML_ASSERT(ggml_is_contiguous(pw))if (!(ggml_is_contiguous(pw))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5689, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(pw)");
  GGML_ASSERT(ggml_is_contiguous(ph))if (!(ggml_is_contiguous(ph))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5690, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(ph)");
  GGML_ASSERT(ph->type == GGML_TYPE_F32)if (!(ph->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5691, "GGML_ASSERT(%s) failed", "ph->type == GGML_TYPE_F32"
);
  GGML_ASSERT(pw->type == GGML_TYPE_F32)if (!(pw->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5692, "GGML_ASSERT(%s) failed", "pw->type == GGML_TYPE_F32"
);
  GGML_ASSERT(pw->ne[3] == a->ne[2])if (!(pw->ne[3] == a->ne[2])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5693, "GGML_ASSERT(%s) failed", "pw->ne[3] == a->ne[2]"
);
  GGML_ASSERT(pw->ne[0]*pw->ne[0] == a->ne[0])if (!(pw->ne[0]*pw->ne[0] == a->ne[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5694, "GGML_ASSERT(%s) failed", "pw->ne[0]*pw->ne[0] == a->ne[0]"
);
  GGML_ASSERT(pw->ne[1]*pw->ne[2] == a->ne[1])if (!(pw->ne[1]*pw->ne[2] == a->ne[1])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5695, "GGML_ASSERT(%s) failed", "pw->ne[1]*pw->ne[2] == a->ne[1]"
);

  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
  ggml_set_op_params_i32(result, 0, inplace ? 1 : 0);

  result->op     = GGML_OP_ADD_REL_POS;
  result->src[0] = a;
  result->src[1] = pw;
  result->src[2] = ph;

  return result;
5706}

5708struct ggml_tensor * ggml_add_rel_pos(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * pw,
      struct ggml_tensor  * ph) {
  return ggml_add_rel_pos_impl(ctx, a, pw, ph, false0);
5714}

5716struct ggml_tensor * ggml_add_rel_pos_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * pw,
      struct ggml_tensor  * ph) {
  return ggml_add_rel_pos_impl(ctx, a, pw, ph, true1);
5722}

5724// ggml_rwkv_wkv6

5726struct ggml_tensor * ggml_rwkv_wkv6(
      struct ggml_context * ctx,
      struct ggml_tensor  * k,
      struct ggml_tensor  * v,
      struct ggml_tensor  * r,
      struct ggml_tensor  * tf,
      struct ggml_tensor  * td,
      struct ggml_tensor  * state) {
  GGML_ASSERT(ggml_is_contiguous(k))if (!(ggml_is_contiguous(k))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5734, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(k)");
  GGML_ASSERT(ggml_is_contiguous(v))if (!(ggml_is_contiguous(v))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5735, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(v)");
  GGML_ASSERT(ggml_is_contiguous(r))if (!(ggml_is_contiguous(r))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5736, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(r)");
  GGML_ASSERT(ggml_is_contiguous(tf))if (!(ggml_is_contiguous(tf))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5737, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(tf)");
  GGML_ASSERT(ggml_is_contiguous(td))if (!(ggml_is_contiguous(td))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5738, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(td)");
  GGML_ASSERT(ggml_is_contiguous(state))if (!(ggml_is_contiguous(state))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5739, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(state)"
);

  const int64_t S = k->ne[0];
  const int64_t H = k->ne[1];
  const int64_t n_tokens = k->ne[2];
  const int64_t n_seqs = state->ne[1];
  {
      GGML_ASSERT(v->ne[0] == S && v->ne[1] == H && v->ne[2] == n_tokens)if (!(v->ne[0] == S && v->ne[1] == H &&
 v->ne[2] == n_tokens)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5746, "GGML_ASSERT(%s) failed", "v->ne[0] == S && v->ne[1] == H && v->ne[2] == n_tokens"
);
      GGML_ASSERT(r->ne[0] == S && r->ne[1] == H && r->ne[2] == n_tokens)if (!(r->ne[0] == S && r->ne[1] == H &&
 r->ne[2] == n_tokens)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5747, "GGML_ASSERT(%s) failed", "r->ne[0] == S && r->ne[1] == H && r->ne[2] == n_tokens"
);
      GGML_ASSERT(td->ne[0] == S && td->ne[1] == H && td->ne[2] == n_tokens)if (!(td->ne[0] == S && td->ne[1] == H &&
 td->ne[2] == n_tokens)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5748, "GGML_ASSERT(%s) failed", "td->ne[0] == S && td->ne[1] == H && td->ne[2] == n_tokens"
);
      GGML_ASSERT(ggml_nelements(state) == S * S * H * n_seqs)if (!(ggml_nelements(state) == S * S * H * n_seqs)) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5749, "GGML_ASSERT(%s) failed", "ggml_nelements(state) == S * S * H * n_seqs"
);
  }

  // concat output and new_state
  const int64_t ne[4] = { S * H, n_tokens + S * n_seqs, 1, 1 };
  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  result->op     = GGML_OP_RWKV_WKV6;
  result->src[0] = k;
  result->src[1] = v;
  result->src[2] = r;
  result->src[3] = tf;
  result->src[4] = td;
  result->src[5] = state;

  return result;
5765}

5767// ggml_gated_linear_attn

5769struct ggml_tensor * ggml_gated_linear_attn(
      struct ggml_context * ctx,
      struct ggml_tensor  * k,
      struct ggml_tensor  * v,
      struct ggml_tensor  * q,
      struct ggml_tensor  * g,
      struct ggml_tensor  * state,
      float scale) {
  GGML_ASSERT(ggml_is_contiguous(k))if (!(ggml_is_contiguous(k))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5777, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(k)");
  GGML_ASSERT(ggml_is_contiguous(v))if (!(ggml_is_contiguous(v))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5778, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(v)");
  GGML_ASSERT(ggml_is_contiguous(q))if (!(ggml_is_contiguous(q))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5779, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(q)");
  GGML_ASSERT(ggml_is_contiguous(g))if (!(ggml_is_contiguous(g))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5780, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(g)");
  GGML_ASSERT(ggml_is_contiguous(state))if (!(ggml_is_contiguous(state))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5781, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(state)"
);

  const int64_t S = k->ne[0];
  const int64_t H = k->ne[1];
  const int64_t n_tokens = k->ne[2];
  const int64_t n_seqs = state->ne[1];
  {
      GGML_ASSERT(v->ne[0] == S && v->ne[1] == H && v->ne[2] == n_tokens)if (!(v->ne[0] == S && v->ne[1] == H &&
 v->ne[2] == n_tokens)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5788, "GGML_ASSERT(%s) failed", "v->ne[0] == S && v->ne[1] == H && v->ne[2] == n_tokens"
);
      GGML_ASSERT(q->ne[0] == S && q->ne[1] == H && q->ne[2] == n_tokens)if (!(q->ne[0] == S && q->ne[1] == H &&
 q->ne[2] == n_tokens)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5789, "GGML_ASSERT(%s) failed", "q->ne[0] == S && q->ne[1] == H && q->ne[2] == n_tokens"
);
      GGML_ASSERT(g->ne[0] == S && g->ne[1] == H && g->ne[2] == n_tokens)if (!(g->ne[0] == S && g->ne[1] == H &&
 g->ne[2] == n_tokens)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5790, "GGML_ASSERT(%s) failed", "g->ne[0] == S && g->ne[1] == H && g->ne[2] == n_tokens"
);
      GGML_ASSERT(ggml_nelements(state) == S * S * H * n_seqs)if (!(ggml_nelements(state) == S * S * H * n_seqs)) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5791, "GGML_ASSERT(%s) failed", "ggml_nelements(state) == S * S * H * n_seqs"
);
  }

  // concat output and new_state
  const int64_t ne[4] = { S * H, n_tokens + S * n_seqs, 1, 1 };
  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  ggml_set_op_params_f32(result, 0, scale);

  result->op     = GGML_OP_GATED_LINEAR_ATTN;
  result->src[0] = k;
  result->src[1] = v;
  result->src[2] = q;
  result->src[3] = g;
  result->src[4] = state;

  return result;
5808}

5810// ggml_rwkv_wkv7

5812struct ggml_tensor * ggml_rwkv_wkv7(
      struct ggml_context * ctx,
      struct ggml_tensor  * r,
      struct ggml_tensor  * w,
      struct ggml_tensor  * k,
      struct ggml_tensor  * v,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      struct ggml_tensor  * state) {
  GGML_ASSERT(ggml_is_contiguous(r))if (!(ggml_is_contiguous(r))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5821, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(r)");
  GGML_ASSERT(ggml_is_contiguous(w))if (!(ggml_is_contiguous(w))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5822, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(w)");
  GGML_ASSERT(ggml_is_contiguous(k))if (!(ggml_is_contiguous(k))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5823, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(k)");
  GGML_ASSERT(ggml_is_contiguous(v))if (!(ggml_is_contiguous(v))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5824, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(v)");
  GGML_ASSERT(ggml_is_contiguous(a))if (!(ggml_is_contiguous(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5825, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(a)");
  GGML_ASSERT(ggml_is_contiguous(b))if (!(ggml_is_contiguous(b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5826, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(b)");
  GGML_ASSERT(ggml_is_contiguous(state))if (!(ggml_is_contiguous(state))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5827, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(state)"
);

  const int64_t S = k->ne[0];
  const int64_t H = k->ne[1];
  const int64_t n_tokens = k->ne[2];
  const int64_t n_seqs = state->ne[1];
  {
      GGML_ASSERT(w->ne[0] == S && w->ne[1] == H && w->ne[2] == n_tokens)if (!(w->ne[0] == S && w->ne[1] == H &&
 w->ne[2] == n_tokens)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5834, "GGML_ASSERT(%s) failed", "w->ne[0] == S && w->ne[1] == H && w->ne[2] == n_tokens"
);
      GGML_ASSERT(k->ne[0] == S && k->ne[1] == H && k->ne[2] == n_tokens)if (!(k->ne[0] == S && k->ne[1] == H &&
 k->ne[2] == n_tokens)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5835, "GGML_ASSERT(%s) failed", "k->ne[0] == S && k->ne[1] == H && k->ne[2] == n_tokens"
);
      GGML_ASSERT(v->ne[0] == S && v->ne[1] == H && v->ne[2] == n_tokens)if (!(v->ne[0] == S && v->ne[1] == H &&
 v->ne[2] == n_tokens)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5836, "GGML_ASSERT(%s) failed", "v->ne[0] == S && v->ne[1] == H && v->ne[2] == n_tokens"
);
      GGML_ASSERT(a->ne[0] == S && a->ne[1] == H && a->ne[2] == n_tokens)if (!(a->ne[0] == S && a->ne[1] == H &&
 a->ne[2] == n_tokens)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5837, "GGML_ASSERT(%s) failed", "a->ne[0] == S && a->ne[1] == H && a->ne[2] == n_tokens"
);
      GGML_ASSERT(b->ne[0] == S && b->ne[1] == H && b->ne[2] == n_tokens)if (!(b->ne[0] == S && b->ne[1] == H &&
 b->ne[2] == n_tokens)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5838, "GGML_ASSERT(%s) failed", "b->ne[0] == S && b->ne[1] == H && b->ne[2] == n_tokens"
);
      GGML_ASSERT(ggml_nelements(state) == S * S * H * n_seqs)if (!(ggml_nelements(state) == S * S * H * n_seqs)) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5839, "GGML_ASSERT(%s) failed", "ggml_nelements(state) == S * S * H * n_seqs"
);
  }

  // concat output and new_state
  const int64_t ne[4] = { S * H, n_tokens + S * n_seqs, 1, 1 };
  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  result->op     = GGML_OP_RWKV_WKV7;
  result->src[0] = r;
  result->src[1] = w;
  result->src[2] = k;
  result->src[3] = v;
  result->src[4] = a;
  result->src[5] = b;
  result->src[6] = state;

  return result;
5856}

5858// ggml_unary

5860static struct ggml_tensor * ggml_unary_impl(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      enum ggml_unary_op    op,
      bool_Bool                  inplace) {
  GGML_ASSERT(ggml_is_contiguous_rows(a))if (!(ggml_is_contiguous_rows(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5865, "GGML_ASSERT(%s) failed", "ggml_is_contiguous_rows(a)"
);

  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  ggml_set_op_params_i32(result, 0, (int32_t) op);

  result->op     = GGML_OP_UNARY;
  result->src[0] = a;

  return result;
5875}

5877struct ggml_tensor * ggml_unary(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      enum ggml_unary_op    op) {
  return ggml_unary_impl(ctx, a, op, false0);
5882}

5884struct ggml_tensor * ggml_unary_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      enum ggml_unary_op    op) {
  return ggml_unary_impl(ctx, a, op, true1);
5889}

5891// ggml_map_custom1

5893static struct ggml_tensor * ggml_map_custom1_impl(
      struct ggml_context      * ctx,
      struct ggml_tensor       * a,
      const  ggml_custom1_op_t   fun,
      int                        n_tasks,
      void                     * userdata,
      bool_Bool                       inplace) {
  GGML_ASSERT(n_tasks == GGML_N_TASKS_MAX || n_tasks > 0)if (!(n_tasks == (-1) || n_tasks > 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5900, "GGML_ASSERT(%s) failed", "n_tasks == GGML_N_TASKS_MAX || n_tasks > 0"
);

  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  struct ggml_map_custom1_op_params params = {
      /*.fun      =*/ fun,
      /*.n_tasks  =*/ n_tasks,
      /*.userdata =*/ userdata
  };
  ggml_set_op_params(result, &params, sizeof(params));

  result->op     = GGML_OP_MAP_CUSTOM1;
  result->src[0] = a;

  return result;
5915}

5917struct ggml_tensor * ggml_map_custom1(
      struct ggml_context      * ctx,
      struct ggml_tensor       * a,
      const  ggml_custom1_op_t   fun,
      int                        n_tasks,
      void                     * userdata) {
  return ggml_map_custom1_impl(ctx, a, fun, n_tasks, userdata, false0);
5924}

5926struct ggml_tensor * ggml_map_custom1_inplace(
      struct ggml_context      * ctx,
      struct ggml_tensor       * a,
      const  ggml_custom1_op_t   fun,
      int                        n_tasks,
      void                     * userdata) {
  return ggml_map_custom1_impl(ctx, a, fun, n_tasks, userdata, true1);
5933}

5935// ggml_map_custom2

5937static struct ggml_tensor * ggml_map_custom2_impl(
      struct ggml_context      * ctx,
      struct ggml_tensor       * a,
      struct ggml_tensor       * b,
      const  ggml_custom2_op_t   fun,
      int                        n_tasks,
      void                     * userdata,
      bool_Bool                       inplace) {
  GGML_ASSERT(n_tasks == GGML_N_TASKS_MAX || n_tasks > 0)if (!(n_tasks == (-1) || n_tasks > 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5945, "GGML_ASSERT(%s) failed", "n_tasks == GGML_N_TASKS_MAX || n_tasks > 0"
);

  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  struct ggml_map_custom2_op_params params = {
      /*.fun      =*/ fun,
      /*.n_tasks  =*/ n_tasks,
      /*.userdata =*/ userdata
  };
  ggml_set_op_params(result, &params, sizeof(params));

  result->op     = GGML_OP_MAP_CUSTOM2;
  result->src[0] = a;
  result->src[1] = b;

  return result;
5961}

5963struct ggml_tensor * ggml_map_custom2(
      struct ggml_context      * ctx,
      struct ggml_tensor       * a,
      struct ggml_tensor       * b,
      const  ggml_custom2_op_t   fun,
      int                        n_tasks,
      void                     * userdata) {
  return ggml_map_custom2_impl(ctx, a, b, fun, n_tasks, userdata, false0);
5971}

5973struct ggml_tensor * ggml_map_custom2_inplace(
      struct ggml_context      * ctx,
      struct ggml_tensor       * a,
      struct ggml_tensor       * b,
      const  ggml_custom2_op_t   fun,
      int                        n_tasks,
      void                     * userdata) {
  return ggml_map_custom2_impl(ctx, a, b, fun, n_tasks, userdata, true1);
5981}

5983// ggml_map_custom3

5985static struct ggml_tensor * ggml_map_custom3_impl(
      struct ggml_context      * ctx,
      struct ggml_tensor       * a,
      struct ggml_tensor       * b,
      struct ggml_tensor       * c,
      const  ggml_custom3_op_t   fun,
      int                        n_tasks,
      void                     * userdata,
      bool_Bool                       inplace) {
  GGML_ASSERT(n_tasks == GGML_N_TASKS_MAX || n_tasks > 0)if (!(n_tasks == (-1) || n_tasks > 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 5994, "GGML_ASSERT(%s) failed", "n_tasks == GGML_N_TASKS_MAX || n_tasks > 0"
);

  struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);

  struct ggml_map_custom3_op_params params = {
      /*.fun      =*/ fun,
      /*.n_tasks  =*/ n_tasks,
      /*.userdata =*/ userdata
  };
  ggml_set_op_params(result, &params, sizeof(params));

  result->op     = GGML_OP_MAP_CUSTOM3;
  result->src[0] = a;
  result->src[1] = b;
  result->src[2] = c;

  return result;
6011}

6013struct ggml_tensor * ggml_map_custom3(
      struct ggml_context      * ctx,
      struct ggml_tensor       * a,
      struct ggml_tensor       * b,
      struct ggml_tensor       * c,
      const  ggml_custom3_op_t   fun,
      int                        n_tasks,
      void                     * userdata) {
  return ggml_map_custom3_impl(ctx, a, b, c, fun, n_tasks, userdata, false0);
6022}

6024struct ggml_tensor * ggml_map_custom3_inplace(
      struct ggml_context      * ctx,
      struct ggml_tensor       * a,
      struct ggml_tensor       * b,
      struct ggml_tensor       * c,
      const  ggml_custom3_op_t   fun,
      int                        n_tasks,
      void                     * userdata) {
  return ggml_map_custom3_impl(ctx, a, b, c, fun, n_tasks, userdata, true1);
6033}

6035struct ggml_tensor * ggml_custom_4d(
      struct ggml_context * ctx,
      enum ggml_type        type,
      int64_t               ne0,
      int64_t               ne1,
      int64_t               ne2,
      int64_t               ne3,
      struct ggml_tensor ** args,
      int                   n_args,
      ggml_custom_op_t      fun,
      int                   n_tasks,
      void                * userdata) {

  GGML_ASSERT(n_args < GGML_MAX_SRC)if (!(n_args < 10)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6048, "GGML_ASSERT(%s) failed", "n_args < GGML_MAX_SRC");

  struct ggml_tensor * result = ggml_new_tensor_4d(ctx, type, ne0, ne1, ne2, ne3);

  struct ggml_custom_op_params params = {
      /*.fun      =*/ fun,
      /*.n_tasks  =*/ n_tasks,
      /*.userdata =*/ userdata
  };
  ggml_set_op_params(result, &params, sizeof(params));

  result->op = GGML_OP_CUSTOM;
  for (int i = 0; i < n_args; i++) {
      result->src[i] = args[i];
  }

  return result;
6065}

6067struct ggml_tensor * ggml_custom_inplace(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor ** args,
      int                   n_args,
      ggml_custom_op_t      fun,
      int                   n_tasks,
      void                * userdata) {

  GGML_ASSERT(n_args < GGML_MAX_SRC - 1)if (!(n_args < 10 - 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6076, "GGML_ASSERT(%s) failed", "n_args < GGML_MAX_SRC - 1"
);

  struct ggml_tensor * result = ggml_view_tensor(ctx, a);

  struct ggml_custom_op_params params = {
      /*.fun      =*/ fun,
      /*.n_tasks  =*/ n_tasks,
      /*.userdata =*/ userdata
  };
  ggml_set_op_params(result, &params, sizeof(params));

  result->op = GGML_OP_CUSTOM;
  result->src[0] = a;
  for (int i = 0; i < n_args; i++) {
      result->src[i + 1] = args[i];
  }

  return result;
6094}
6095// ggml_cross_entropy_loss

6097struct ggml_tensor * ggml_cross_entropy_loss(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b) {
  GGML_ASSERT(ggml_are_same_shape(a, b))if (!(ggml_are_same_shape(a, b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6101, "GGML_ASSERT(%s) failed", "ggml_are_same_shape(a, b)"
);

  struct ggml_tensor * result = ggml_new_tensor_1d(ctx, a->type, 1);

  result->op     = GGML_OP_CROSS_ENTROPY_LOSS;
  result->src[0] = a;
  result->src[1] = b;

  return result;
6110}

6112// ggml_cross_entropy_loss_back

6114struct ggml_tensor * ggml_cross_entropy_loss_back(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      struct ggml_tensor  * c) {
  GGML_ASSERT(ggml_is_scalar(a))if (!(ggml_is_scalar(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6119, "GGML_ASSERT(%s) failed", "ggml_is_scalar(a)");
  GGML_ASSERT(ggml_are_same_shape(b, c))if (!(ggml_are_same_shape(b, c))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6120, "GGML_ASSERT(%s) failed", "ggml_are_same_shape(b, c)"
);

  struct ggml_tensor * result = ggml_dup_tensor(ctx, b);

  result->op     = GGML_OP_CROSS_ENTROPY_LOSS_BACK;
  result->src[0] = a;
  result->src[1] = b;
  result->src[2] = c;

  return result;
6130}

6132// opt_step_adamw

6134struct ggml_tensor * ggml_opt_step_adamw(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * grad,
      struct ggml_tensor  * m,
      struct ggml_tensor  * v,
      struct ggml_tensor  * adamw_params) {
  GGML_ASSERT(a->flags & GGML_TENSOR_FLAG_PARAM)if (!(a->flags & GGML_TENSOR_FLAG_PARAM)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6141, "GGML_ASSERT(%s) failed", "a->flags & GGML_TENSOR_FLAG_PARAM"
);
  GGML_ASSERT(ggml_are_same_shape(a, grad))if (!(ggml_are_same_shape(a, grad))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6142, "GGML_ASSERT(%s) failed", "ggml_are_same_shape(a, grad)"
);
  GGML_ASSERT(ggml_are_same_shape(a, m))if (!(ggml_are_same_shape(a, m))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6143, "GGML_ASSERT(%s) failed", "ggml_are_same_shape(a, m)"
);
  GGML_ASSERT(ggml_are_same_shape(a, v))if (!(ggml_are_same_shape(a, v))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6144, "GGML_ASSERT(%s) failed", "ggml_are_same_shape(a, v)"
);
  GGML_ASSERT(adamw_params->type == GGML_TYPE_F32)if (!(adamw_params->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6145, "GGML_ASSERT(%s) failed", "adamw_params->type == GGML_TYPE_F32"
);
  GGML_ASSERT(ggml_nelements(adamw_params) == 7)if (!(ggml_nelements(adamw_params) == 7)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6146, "GGML_ASSERT(%s) failed", "ggml_nelements(adamw_params) == 7"
);

  struct ggml_tensor * result = ggml_view_tensor(ctx, a);

  result->op     = GGML_OP_OPT_STEP_ADAMW;
  result->src[0] = a;
  result->src[1] = grad;
  result->src[2] = m;
  result->src[3] = v;
  result->src[4] = adamw_params;

  return result;
6158}

6160// opt_step_sgd

6162struct ggml_tensor * ggml_opt_step_sgd(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * grad,
      struct ggml_tensor  * params) {
  GGML_ASSERT(a->flags & GGML_TENSOR_FLAG_PARAM)if (!(a->flags & GGML_TENSOR_FLAG_PARAM)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6167, "GGML_ASSERT(%s) failed", "a->flags & GGML_TENSOR_FLAG_PARAM"
);
  GGML_ASSERT(ggml_are_same_shape(a, grad))if (!(ggml_are_same_shape(a, grad))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6168, "GGML_ASSERT(%s) failed", "ggml_are_same_shape(a, grad)"
);
  GGML_ASSERT(params->type == GGML_TYPE_F32)if (!(params->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6169, "GGML_ASSERT(%s) failed", "params->type == GGML_TYPE_F32"
);
  GGML_ASSERT(ggml_nelements(params) == 2)if (!(ggml_nelements(params) == 2)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6170, "GGML_ASSERT(%s) failed", "ggml_nelements(params) == 2"
);

  struct ggml_tensor * result = ggml_view_tensor(ctx, a);

  result->op     = GGML_OP_OPT_STEP_SGD;
  result->src[0] = a;
  result->src[1] = grad;
  result->src[2] = params;

  return result;
6180}

6182// solve_tri

6184struct ggml_tensor * ggml_solve_tri(
      struct ggml_context * ctx,
      struct ggml_tensor  * a,
      struct ggml_tensor  * b,
      bool_Bool                  left,
      bool_Bool                  lower,
      bool_Bool                  uni) {
  GGML_ASSERT(a->type == GGML_TYPE_F32)if (!(a->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6191, "GGML_ASSERT(%s) failed", "a->type == GGML_TYPE_F32"
);
  GGML_ASSERT(b->type == GGML_TYPE_F32)if (!(b->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6192, "GGML_ASSERT(%s) failed", "b->type == GGML_TYPE_F32"
);

  // A must be square and lower diagonal
  GGML_ASSERT(a->ne[0] == a->ne[1])if (!(a->ne[0] == a->ne[1])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6195, "GGML_ASSERT(%s) failed", "a->ne[0] == a->ne[1]"
);
  // B must have same outer dimension as A
  GGML_ASSERT(a->ne[1] == b->ne[1])if (!(a->ne[1] == b->ne[1])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6197, "GGML_ASSERT(%s) failed", "a->ne[1] == b->ne[1]"
);

  // batch dimensions must be equal
  GGML_ASSERT(a->ne[2] == b->ne[2])if (!(a->ne[2] == b->ne[2])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6200, "GGML_ASSERT(%s) failed", "a->ne[2] == b->ne[2]"
);
  GGML_ASSERT(a->ne[3] == b->ne[3])if (!(a->ne[3] == b->ne[3])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6201, "GGML_ASSERT(%s) failed", "a->ne[3] == b->ne[3]"
);

  GGML_ASSERT(ggml_is_contiguous(a))if (!(ggml_is_contiguous(a))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6203, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(a)");
  GGML_ASSERT(ggml_is_contiguous(b))if (!(ggml_is_contiguous(b))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6204, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(b)");

  GGML_ASSERT(lower && left && !uni)if (!(lower && left && !uni)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6206, "GGML_ASSERT(%s) failed", "lower && left && !uni"
); // TODO: support other variants

  struct ggml_tensor * result = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, b->ne[0], b->ne[1], b->ne[2], b->ne[3]);

  result->op     = GGML_OP_SOLVE_TRI;
  result->src[0] = a;
  result->src[1] = b;

  return result;
6215}

6217// ggml_gated_delta_net

6219struct ggml_tensor * ggml_gated_delta_net(
      struct ggml_context * ctx,
      struct ggml_tensor  * q,
      struct ggml_tensor  * k,
      struct ggml_tensor  * v,
      struct ggml_tensor  * g,
      struct ggml_tensor  * beta,
      struct ggml_tensor  * state,
      int64_t               K) {
  GGML_ASSERT(ggml_is_contiguous_rows(q))if (!(ggml_is_contiguous_rows(q))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6228, "GGML_ASSERT(%s) failed", "ggml_is_contiguous_rows(q)"
);
  GGML_ASSERT(ggml_is_contiguous_rows(k))if (!(ggml_is_contiguous_rows(k))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6229, "GGML_ASSERT(%s) failed", "ggml_is_contiguous_rows(k)"
);
  GGML_ASSERT(ggml_is_contiguous_rows(v))if (!(ggml_is_contiguous_rows(v))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6230, "GGML_ASSERT(%s) failed", "ggml_is_contiguous_rows(v)"
);
  GGML_ASSERT(ggml_is_contiguous(g))if (!(ggml_is_contiguous(g))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6231, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(g)");
  GGML_ASSERT(ggml_is_contiguous(beta))if (!(ggml_is_contiguous(beta))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6232, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(beta)");
  GGML_ASSERT(ggml_is_contiguous(state))if (!(ggml_is_contiguous(state))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6233, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(state)"
);

  GGML_ASSERT(q->type == GGML_TYPE_F32)if (!(q->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6235, "GGML_ASSERT(%s) failed", "q->type == GGML_TYPE_F32"
);
  GGML_ASSERT(k->type == GGML_TYPE_F32)if (!(k->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6236, "GGML_ASSERT(%s) failed", "k->type == GGML_TYPE_F32"
);
  GGML_ASSERT(v->type == GGML_TYPE_F32)if (!(v->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6237, "GGML_ASSERT(%s) failed", "v->type == GGML_TYPE_F32"
);
  GGML_ASSERT(g->type == GGML_TYPE_F32)if (!(g->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6238, "GGML_ASSERT(%s) failed", "g->type == GGML_TYPE_F32"
);
  GGML_ASSERT(beta->type == GGML_TYPE_F32)if (!(beta->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6239, "GGML_ASSERT(%s) failed", "beta->type == GGML_TYPE_F32"
);
  GGML_ASSERT(state->type == GGML_TYPE_F32)if (!(state->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6240, "GGML_ASSERT(%s) failed", "state->type == GGML_TYPE_F32"
);

  const int64_t S_v      = v->ne[0];
  const int64_t H        = v->ne[1];
  const int64_t n_tokens = v->ne[2];
  const int64_t n_seqs   = v->ne[3];

  // gate: scalar [1, H, T, B] or vector [S_v, H, T, B] (KDA)
  GGML_ASSERT(g->ne[0] == 1 || g->ne[0] == S_v)if (!(g->ne[0] == 1 || g->ne[0] == S_v)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6248, "GGML_ASSERT(%s) failed", "g->ne[0] == 1 || g->ne[0] == S_v"
);
  GGML_ASSERT(beta->ne[0] == 1)if (!(beta->ne[0] == 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6249, "GGML_ASSERT(%s) failed", "beta->ne[0] == 1");

  // state holds the initial state s0 only: [S_v, S_v, H, n_seqs]. K (snapshot slot count) is an op param.
  GGML_ASSERT(state->ne[0] == S_v)if (!(state->ne[0] == S_v)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6252, "GGML_ASSERT(%s) failed", "state->ne[0] == S_v");
  GGML_ASSERT(state->ne[1] == S_v)if (!(state->ne[1] == S_v)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6253, "GGML_ASSERT(%s) failed", "state->ne[1] == S_v");
  GGML_ASSERT(state->ne[2] == H)if (!(state->ne[2] == H)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6254, "GGML_ASSERT(%s) failed", "state->ne[2] == H");
  GGML_ASSERT(state->ne[3] == n_seqs)if (!(state->ne[3] == n_seqs)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6255, "GGML_ASSERT(%s) failed", "state->ne[3] == n_seqs"
);
  GGML_ASSERT(K >= 1)if (!(K >= 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6256, "GGML_ASSERT(%s) failed", "K >= 1");
  const int64_t state_rows = K * S_v * n_seqs;
  const int64_t ne[4] = { S_v * H, n_tokens * n_seqs + state_rows, 1, 1 };
  struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);

  ggml_set_op_params_i32(result, 0, (int32_t) K);

  result->op     = GGML_OP_GATED_DELTA_NET;
  result->src[0] = q;
  result->src[1] = k;
  result->src[2] = v;
  result->src[3] = g;
  result->src[4] = beta;
  result->src[5] = state;

  return result;
6272}

6274////////////////////////////////////////////////////////////////////////////////

6276struct ggml_hash_set ggml_hash_set_new(size_t size) {
  size = ggml_hash_size(size);
  struct ggml_hash_set result;
  result.size = size;
  result.keys = GGML_MALLOC(sizeof(struct ggml_tensor *) * size)ggml_malloc(sizeof(struct ggml_tensor *) * size);
  result.used = GGML_CALLOC(ggml_bitset_size(size), sizeof(ggml_bitset_t))ggml_calloc(ggml_bitset_size(size), sizeof(ggml_bitset_t));
  return result;
6283}

6285void ggml_hash_set_reset(struct ggml_hash_set * hash_set) {
  memset(hash_set->used, 0, sizeof(ggml_bitset_t) * ggml_bitset_size(hash_set->size));
6287}

6289void ggml_hash_set_free(struct ggml_hash_set * hash_set) {
  GGML_FREE(hash_set->used)free(hash_set->used);
  GGML_FREE(hash_set->keys)free(hash_set->keys);
6292}

6294size_t ggml_hash_size(size_t min_sz) {
  // next primes after powers of two
  static const size_t primes[] = {
      2, 3, 5, 11, 17, 37, 67, 131, 257, 521, 1031,
      2053, 4099, 8209, 16411, 32771, 65537, 131101,
      262147, 524309, 1048583, 2097169, 4194319, 8388617,
      16777259, 33554467, 67108879, 134217757, 268435459,
      536870923, 1073741827, 2147483659
  };
  static const size_t n_primes = sizeof(primes)/sizeof(primes[0]);

  // find the smallest prime that is larger or equal than min_sz
  size_t l = 0;
  size_t r = n_primes;
  while (l < r) {
      size_t m = (l + r)/2;
      if (primes[m] < min_sz) {
          l = m + 1;
      } else {
          r = m;
      }
  }
  size_t sz = l < n_primes ? primes[l] : min_sz | 1;
  return sz;
6318}

6320struct hash_map {
  struct ggml_hash_set set;
  struct ggml_tensor ** vals;
6323};

6325static struct hash_map * ggml_new_hash_map(size_t size) {
  struct hash_map * result = GGML_MALLOC(sizeof(struct hash_map))ggml_malloc(sizeof(struct hash_map));
  result->set = ggml_hash_set_new(size);
  result->vals = GGML_CALLOC(result->set.size, sizeof(struct ggml_tensor *))ggml_calloc(result->set.size, sizeof(struct ggml_tensor *)
);
  return result;
6330}

6332static void ggml_hash_map_free(struct hash_map * map) {
  ggml_hash_set_free(&map->set);
  GGML_FREE(map->vals)free(map->vals);
  GGML_FREE(map)free(map);
6336}

6338// utility functions to change gradients
6339// isrc is the index of tensor in cgraph->visited_has_set.keys
6340// the corresponding gradient (accumulators) are also at position isrc
6341// if tensor has a gradient accumulator, modify that accumulator in-place
6342// else if there is no gradient for tensor, set the corresponding value
6343// else, just add/subtract/etc. the gradients

6345static void ggml_add_or_set(
      struct ggml_context * ctx,
      struct ggml_cgraph  * cgraph,
      size_t                isrc,
      struct ggml_tensor  * tensor) {
  struct ggml_tensor * src = cgraph->visited_hash_set.keys[isrc];
  GGML_ASSERT(src)if (!(src)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6351, "GGML_ASSERT(%s) failed", "src");
  if (cgraph->grads[isrc]) {
      cgraph->grads[isrc] = ggml_add_impl(ctx, cgraph->grads[isrc], tensor, /*inplace =*/ cgraph->grad_accs[isrc]);
  } else {
      cgraph->grads[isrc] = tensor;
  }
  ggml_format_name(cgraph->grads[isrc], "grad for %s", src->name);
  ggml_build_forward_expand(cgraph, cgraph->grads[isrc]);
6359}

6361static void ggml_acc_or_set(
      struct ggml_context * ctx,
      struct ggml_cgraph  * cgraph,
      size_t                isrc,
      struct ggml_tensor  * tensor,
      const  size_t         nb1,
      const  size_t         nb2,
      const  size_t         nb3,
      const  size_t         offset) {
  struct ggml_tensor * src = cgraph->visited_hash_set.keys[isrc];
  GGML_ASSERT(src)if (!(src)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6371, "GGML_ASSERT(%s) failed", "src");
  if (cgraph->grads[isrc]) {
      cgraph->grads[isrc] = ggml_acc_impl(ctx, cgraph->grads[isrc], tensor, nb1, nb2, nb3, offset, cgraph->grad_accs[isrc]);
  } else {
      struct ggml_tensor * a_zero = ggml_scale(ctx, src, 0.0f); // FIXME this is going to produce NaN if a contains inf/NaN
      cgraph->grads[isrc] = ggml_acc_impl(ctx, a_zero, tensor, nb1, nb2, nb3, offset, false0);
  }
  ggml_format_name(cgraph->grads[isrc], "grad for %s", cgraph->visited_hash_set.keys[isrc]->name);
  ggml_build_forward_expand(cgraph, cgraph->grads[isrc]);
6380}

6382static void ggml_add1_or_set(
      struct ggml_context * ctx,
      struct ggml_cgraph  * cgraph,
      size_t                isrc,
      struct ggml_tensor  * tensor) {
  struct ggml_tensor * src = cgraph->visited_hash_set.keys[isrc];
  GGML_ASSERT(src)if (!(src)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6388, "GGML_ASSERT(%s) failed", "src");
  if (cgraph->grads[isrc]) {
      cgraph->grads[isrc] = ggml_add1_impl(ctx, cgraph->grads[isrc], tensor, cgraph->grad_accs[isrc]);
  } else {
      cgraph->grads[isrc] = ggml_repeat(ctx, tensor, src);
  }
  ggml_format_name(cgraph->grads[isrc], "grad for %s", src->name);
  ggml_build_forward_expand(cgraph, cgraph->grads[isrc]);
6396}

6398static void ggml_sub_or_set(
      struct ggml_context * ctx,
      struct ggml_cgraph  * cgraph,
      size_t                isrc,
      struct ggml_tensor  * tensor) {
  struct ggml_tensor * src = cgraph->visited_hash_set.keys[isrc];
  GGML_ASSERT(src)if (!(src)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6404, "GGML_ASSERT(%s) failed", "src");
  if (cgraph->grads[isrc]) {
      cgraph->grads[isrc] = ggml_sub_impl(ctx, cgraph->grads[isrc], tensor, cgraph->grad_accs[isrc]);
  } else {
      cgraph->grads[isrc] = ggml_neg(ctx, tensor);
  }
  ggml_format_name(cgraph->grads[isrc], "grad for %s", src->name);
  ggml_build_forward_expand(cgraph, cgraph->grads[isrc]);
6412}

6414static void ggml_compute_backward(
      struct ggml_context * ctx, struct ggml_cgraph * cgraph, int i, const bool_Bool * grads_needed) {
  struct ggml_tensor * tensor = cgraph->nodes[i];
  struct ggml_tensor * grad   = ggml_graph_get_grad(cgraph, tensor);

  if (!grad) {
1
Assuming 'grad' is non-null→
2
←
Taking false branch→
      return;
  }

  struct ggml_tensor * src0 = tensor->src[0];
3
←
'src0' initialized here→
  struct ggml_tensor * src1 = tensor->src[1];
  struct ggml_tensor * src2 = tensor->src[2];
  struct ggml_hash_set * hash_set = &cgraph->visited_hash_set;
  const size_t isrc0 = src0 ? ggml_hash_find(hash_set, src0) : (size_t) -1;
4
←
Assuming 'src0' is null→
5
←
'?' condition is false→
  const size_t isrc1 = src1 ? ggml_hash_find(hash_set, src1) : (size_t) -1;
6
←
Assuming 'src1' is non-null→
7
←
'?' condition is true→
  const size_t isrc2 = src2 ? ggml_hash_find(hash_set, src2) : (size_t) -1;
8
←
Assuming 'src2' is null→
9
←
'?' condition is false→
  const bool_Bool src0_needs_grads = src09.1
'src0' is null
 && isrc0 != GGML_HASHSET_FULL((size_t)-1) && ggml_bitset_get(hash_set->used, isrc0) && grads_needed[isrc0];
  const bool_Bool src1_needs_grads = src19.2
'src1' is non-null
 && isrc1 != GGML_HASHSET_FULL((size_t)-1) && ggml_bitset_get(hash_set->used, isrc1) && grads_needed[isrc1];
10
←
Assuming the condition is true→
11
←
Assuming the condition is true→
  const bool_Bool src2_needs_grads = src211.1
'src2' is null
 && isrc2 != GGML_HASHSET_FULL((size_t)-1) && ggml_bitset_get(hash_set->used, isrc2) && grads_needed[isrc2];

  switch (tensor->op) {
12
←
Control jumps to 'case GGML_OP_MUL:'  at line 6485→
      case GGML_OP_DUP: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, grad);
          }
      } break;
      case GGML_OP_ADD: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, grad);
          }
          if (src1_needs_grads) {
              struct ggml_tensor * tmp = grad;
              if (!ggml_are_same_shape(src0, src1)) {
                  tmp = ggml_repeat_back(ctx, tmp, src1);
              }
              ggml_add_or_set(ctx, cgraph, isrc1, tmp);
          }
      } break;
      case GGML_OP_ADD1: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, grad);
          }
          if (src1_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc1, ggml_mean(ctx, grad)); // TODO: should probably be sum instead of mean
          }
      } break;
      case GGML_OP_ACC: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, grad);
          }
          if (src1_needs_grads) {
              const size_t nb1    = ((int32_t *) tensor->op_params)[0];
              const size_t nb2    = ((int32_t *) tensor->op_params)[1];
              const size_t nb3    = ((int32_t *) tensor->op_params)[2];
              const size_t offset = ((int32_t *) tensor->op_params)[3];

              struct ggml_tensor * tensor_grad_view = ggml_view_4d(ctx,
                  grad, src1->ne[0], src1->ne[1], src1->ne[2], src1->ne[3],
                  nb1, nb2, nb3, offset);

              ggml_add_or_set(ctx, cgraph, isrc1, ggml_reshape(ctx, ggml_cont(ctx, tensor_grad_view), src1));
          }
      } break;
      case GGML_OP_SUB: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, grad);
          }
          if (src1_needs_grads) {
              ggml_sub_or_set(ctx, cgraph, isrc1, grad);
          }
      } break;
      case GGML_OP_MUL: {
          if (src0_needs_grads12.1
'src0_needs_grads' is false
) {
13
←
Taking false branch→
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_mul(ctx, grad, src1));
          }
          if (src1_needs_grads) {
14
←
Assuming 'src1_needs_grads' is true→
15
←
Taking true branch→
              struct ggml_tensor * tmp = ggml_mul(ctx, src0, grad);
16
←
Passing null pointer value via 2nd parameter 'a'→
17
←
Calling 'ggml_mul'→
              if (!ggml_are_same_shape(src0, src1)) {
                  tmp = ggml_repeat_back(ctx, tmp, src1);
              }
              ggml_add_or_set(ctx, cgraph, isrc1, tmp);
          }
      } break;
      case GGML_OP_DIV: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_div(ctx, grad, src1));
          }
          if (src1_needs_grads) {
              ggml_sub_or_set(ctx, cgraph, isrc1, ggml_mul(ctx, grad, ggml_div(ctx, tensor, src1)));
          }
      } break;
      case GGML_OP_SQR: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_scale(ctx, ggml_mul(ctx, src0, grad), 2.0f));
          }
      } break;
      case GGML_OP_SQRT: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_scale(ctx, ggml_div(ctx, grad, tensor), 0.5f));
          }
      } break;
      case GGML_OP_LOG: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_div(ctx, grad, src0));
          }
      } break;
      case GGML_OP_SIN: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_mul(ctx, grad, ggml_cos(ctx, src0)));
          }
      } break;
      case GGML_OP_COS: {
          if (src0_needs_grads) {
              ggml_sub_or_set(ctx, cgraph, isrc0, ggml_mul(ctx, grad, ggml_sin(ctx, src0)));
          }
      } break;
      case GGML_OP_SUM: {
          if (src0_needs_grads) {
              ggml_add1_or_set(ctx, cgraph, isrc0, grad);
          }
      } break;
      case GGML_OP_SUM_ROWS: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_repeat(ctx, grad, src0));
          }
      } break;
      case GGML_OP_MEAN: {
          if (src0_needs_grads) {
              ggml_add1_or_set(ctx, cgraph, isrc0, ggml_scale_impl(ctx, grad, 1.0f/src0->ne[0], 0.0, false0));
          }
      } break;
      case GGML_OP_REPEAT: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_repeat_back(ctx, grad, src0));
          }
      } break;
      case GGML_OP_REPEAT_BACK: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_repeat(ctx, grad, src0));
          }
      } break;
      case GGML_OP_RMS_NORM: {
          if (src0_needs_grads) {
              float eps;
              memcpy(&eps, tensor->op_params, sizeof(float));
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_rms_norm_back(ctx, grad, src0, eps));
          }
      } break;
      case GGML_OP_MUL_MAT: {
          // https://cs231n.github.io/optimization-2/#staged
          // # forward pass
          // s0 = np.random.randn(5, 10)
          // s1 = np.random.randn(10, 3)
          // t = s0.dot(s1)

          // # now suppose we had the gradient on t from above in the circuit
          // dt = np.random.randn(*t.shape) # same shape as t
          // ds0 = dt.dot(s1.T) #.T gives the transpose of the matrix
          // ds1 = t.T.dot(dt)

          // tensor.shape [m,p,qq,rr]
          // src0.shape   [n,m,q1,r1]
          // src1.shape   [n,p,qq,rr]

          if (src0_needs_grads) {
              GGML_ASSERT(grad->ne[2] == src1->ne[2])if (!(grad->ne[2] == src1->ne[2])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6579, "GGML_ASSERT(%s) failed", "grad->ne[2] == src1->ne[2]"
);
              GGML_ASSERT(grad->ne[3] == src1->ne[3])if (!(grad->ne[3] == src1->ne[3])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6580, "GGML_ASSERT(%s) failed", "grad->ne[3] == src1->ne[3]"
);
              struct ggml_tensor * tmp =
                  ggml_out_prod(ctx, // [n,m,qq,rr]
                      src1,          // [n,p,qq,rr]
                      grad);         // [m,p,qq,rr]
              if (!ggml_are_same_shape(tmp, src0)) {
                  GGML_ASSERT(tmp->ne[0] == src0->ne[0])if (!(tmp->ne[0] == src0->ne[0])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6586, "GGML_ASSERT(%s) failed", "tmp->ne[0] == src0->ne[0]"
);
                  GGML_ASSERT(tmp->ne[1] == src0->ne[1])if (!(tmp->ne[1] == src0->ne[1])) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6587, "GGML_ASSERT(%s) failed", "tmp->ne[1] == src0->ne[1]"
);
                  GGML_ASSERT(tmp->ne[3] == 1)if (!(tmp->ne[3] == 1)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6588, "GGML_ASSERT(%s) failed", "tmp->ne[3] == 1");

                  const int64_t nr2 = tmp->ne[2] / src0->ne[2];
                  const size_t nb2 = tmp->nb[2] * nr2;
                  const size_t nb3 = tmp->nb[2];

                  tmp = ggml_view_4d(ctx, tmp, src0->ne[0], src0->ne[1], src0->ne[2], nr2, tmp->nb[1], nb2, nb3, 0);
                  tmp = ggml_repeat_back(ctx, tmp, src0);
              }
              ggml_add_or_set(ctx, cgraph, isrc0, tmp);
          }
          if (src1_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc1,
                      // ggml_mul_mat(ctx,                   // [n,p,qq,rr]
                      //     ggml_cont(ctx,                  // [m,n,q1,r1]
                      //         ggml_transpose(ctx, src0)), // [m,n,q1,r1]
                      //     grad),                          // [m,p,qq,rr]

                      // when src0 is bigger than tensor->grad (this is mostly the case in llama),
                      // avoid transpose of src0, rather transpose smaller tensor->grad
                      // and then use ggml_out_prod
                      ggml_out_prod(ctx,      // [n,p,qq,rr]
                          src0,               // [n,m,q1,r1]
                          ggml_transpose(ctx, // [p,m,qq,rr]
                              grad)));        // [m,p,qq,rr]
          }
      } break;
      case GGML_OP_SCALE: {
          if (src0_needs_grads) {
              float s;
              memcpy(&s, tensor->op_params, sizeof(float));
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_scale_impl(ctx, grad, s, 0.0, false0));
          }
      } break;
      case GGML_OP_SET: {
          const size_t nb1    = ((const int32_t *) tensor->op_params)[0];
          const size_t nb2    = ((const int32_t *) tensor->op_params)[1];
          const size_t nb3    = ((const int32_t *) tensor->op_params)[2];
          const size_t offset = ((const int32_t *) tensor->op_params)[3];

          struct ggml_tensor * tensor_grad_view = NULL((void*)0);

          if (src0_needs_grads || src1_needs_grads) {
              GGML_ASSERT(src0->type == tensor->type)if (!(src0->type == tensor->type)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6631, "GGML_ASSERT(%s) failed", "src0->type == tensor->type"
);
              GGML_ASSERT(!cgraph->grads[isrc0] ||                      cgraph->grads[isrc0]->type == grad->type)if (!(!cgraph->grads[isrc0] || cgraph->grads[isrc0]->
type == grad->type)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6632, "GGML_ASSERT(%s) failed", "!cgraph->grads[isrc0] || cgraph->grads[isrc0]->type == grad->type"
);
              GGML_ASSERT(!cgraph->grads[isrc1] || !src1_needs_grads || cgraph->grads[isrc1]->type == grad->type)if (!(!cgraph->grads[isrc1] || !src1_needs_grads || cgraph
->grads[isrc1]->type == grad->type)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6633, "GGML_ASSERT(%s) failed", "!cgraph->grads[isrc1] || !src1_needs_grads || cgraph->grads[isrc1]->type == grad->type"
);

              tensor_grad_view = ggml_view_4d(ctx,
                  grad, src1->ne[0], src1->ne[1], src1->ne[2], src1->ne[3],
                  nb1, nb2, nb3, offset);
          }

          if (src0_needs_grads) {
              struct ggml_tensor * tmp = ggml_neg(ctx, tensor_grad_view);
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_acc_impl(ctx, grad, tmp, nb1, nb2, nb3, offset, false0));
          }

          if (src1_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc1, ggml_reshape(ctx, ggml_cont(ctx, tensor_grad_view), src1));
          }
      } break;
      case GGML_OP_CPY: {
          // cpy overwrites value of src1 by src0 and returns view(src1)
          // the overwriting is mathematically equivalent to:
          // tensor = src0 * 1 + src1 * 0
          if (src0_needs_grads) {
              // dsrc0 = dtensor * 1
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_reshape(ctx, grad, src0));
          }
          if (src1_needs_grads) {
              // dsrc1 = dtensor * 0 -> noop
          }
      } break;
      case GGML_OP_CONT: {
          // same as cpy
          if (src0_needs_grads) {
              GGML_ASSERT(!cgraph->grads[isrc0] || ggml_is_contiguous(cgraph->grads[isrc0]))if (!(!cgraph->grads[isrc0] || ggml_is_contiguous(cgraph->
grads[isrc0]))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6664, "GGML_ASSERT(%s) failed", "!cgraph->grads[isrc0] || ggml_is_contiguous(cgraph->grads[isrc0])"
);
              GGML_ASSERT(ggml_is_contiguous(grad))if (!(ggml_is_contiguous(grad))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6665, "GGML_ASSERT(%s) failed", "ggml_is_contiguous(grad)");
              GGML_ASSERT(ggml_nelements(tensor) == ggml_nelements(src0))if (!(ggml_nelements(tensor) == ggml_nelements(src0))) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6666, "GGML_ASSERT(%s) failed", "ggml_nelements(tensor) == ggml_nelements(src0)"
);
              ggml_add_or_set(ctx, cgraph, isrc0,
                  ggml_are_same_shape(tensor, src0) ? grad : ggml_reshape(ctx, grad, src0));
          }
      } break;
      case GGML_OP_RESHAPE: {
          if (src0_needs_grads) {
              struct ggml_tensor * grad_cont = ggml_is_contiguous(grad) ? grad : ggml_cont(ctx, grad);
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_reshape(ctx, grad_cont, src0));
          }
      } break;
      case GGML_OP_VIEW: {
          if (src0_needs_grads) {
              size_t offset;

              memcpy(&offset, tensor->op_params, sizeof(offset));

              size_t nb1 = tensor->nb[1];
              size_t nb2 = tensor->nb[2];
              size_t nb3 = tensor->nb[3];

              if (cgraph->grads[isrc0] && src0->type != cgraph->grads[isrc0]->type) {
                  // gradient is typically F32, but src0 could be other type
                  size_t ng = ggml_element_size(cgraph->grads[isrc0]);
                  size_t n0 = ggml_element_size(src0);
                  GGML_ASSERT(offset % n0 == 0)if (!(offset % n0 == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6691, "GGML_ASSERT(%s) failed", "offset % n0 == 0");
                  GGML_ASSERT(nb1 % n0 == 0)if (!(nb1 % n0 == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6692, "GGML_ASSERT(%s) failed", "nb1 % n0 == 0");
                  GGML_ASSERT(nb2 % n0 == 0)if (!(nb2 % n0 == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6693, "GGML_ASSERT(%s) failed", "nb2 % n0 == 0");
                  GGML_ASSERT(nb3 % n0 == 0)if (!(nb3 % n0 == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6694, "GGML_ASSERT(%s) failed", "nb3 % n0 == 0");
                  offset = (offset / n0) * ng;
                  nb1 = (nb1 / n0) * ng;
                  nb2 = (nb2 / n0) * ng;
                  nb3 = (nb3 / n0) * ng;
              }

              ggml_acc_or_set(ctx, cgraph, isrc0, grad, nb1, nb2, nb3, offset);
          }
      } break;
      case GGML_OP_PERMUTE: {
          if (src0_needs_grads) {
              const int32_t * axes = (const int32_t *) tensor->op_params;
              const int axis0 = axes[0] & 0x3;
              const int axis1 = axes[1] & 0x3;
              const int axis2 = axes[2] & 0x3;
              const int axis3 = axes[3] & 0x3;
              int axb[4] = {0,0,0,0}; // axes backward
              axb[axis0] = 0;
              axb[axis1] = 1;
              axb[axis2] = 2;
              axb[axis3] = 3;
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_permute(ctx, grad, axb[0], axb[1], axb[2], axb[3]));
          }
      } break;
      case GGML_OP_TRANSPOSE: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_transpose(ctx, grad));
          }
      } break;
      case GGML_OP_GET_ROWS: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_get_rows_back(ctx, grad, src1, src0));
          }
          if (src1_needs_grads) {
              // noop
          }
      } break;
      case GGML_OP_DIAG_MASK_INF: {
          if (src0_needs_grads) {
              /* ggml_diag_mask_inf_impl() shouldn't be here */
              /* ref:  https://github.com/ggml-org/llama.cpp/pull/4203#discussion_r1412377992 */
              const int n_past = ((const int32_t *) tensor->op_params)[0];
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_diag_mask_zero_impl(ctx, grad, n_past, false0));
          }
      } break;
      case GGML_OP_DIAG_MASK_ZERO: {
          if (src0_needs_grads) {
              const int n_past = ((const int32_t *) tensor->op_params)[0];
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_diag_mask_zero_impl(ctx, grad, n_past, false0));
          }
      } break;
      case GGML_OP_SOFT_MAX: {
          if (src0_needs_grads) {
              float scale    = 1.0f;
              float max_bias = 0.0f;

              memcpy(&scale,    (const float *) tensor->op_params + 0, sizeof(float));
              memcpy(&max_bias, (const float *) tensor->op_params + 1, sizeof(float));

              ggml_add_or_set(ctx, cgraph, isrc0, ggml_soft_max_ext_back(ctx, grad, tensor, scale, max_bias));
          }
          GGML_ASSERT((!src1 || !src1_needs_grads) && "backward pass for softmax mask not implemented")if (!((!src1 || !src1_needs_grads) && "backward pass for softmax mask not implemented"
)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6756, "GGML_ASSERT(%s) failed", "(!src1 || !src1_needs_grads) && \"backward pass for softmax mask not implemented\""
);
      } break;
      case GGML_OP_ROPE: {
          if (src0_needs_grads) {
              //const int n_past = ((int32_t *) tensor->op_params)[0];
              const int n_dims     = ((const int32_t *) tensor->op_params)[1];
              const int mode       = ((const int32_t *) tensor->op_params)[2];
              //const int n_ctx      = ((int32_t *) tensor->op_params)[3];
              const int n_ctx_orig = ((const int32_t *) tensor->op_params)[4];
              float freq_base, freq_scale, ext_factor, attn_factor, beta_fast, beta_slow;
              int sections[4] = {0, 0, 0, 0};

              memcpy(&freq_base,   (const float *) tensor->op_params +  5, sizeof(float));
              memcpy(&freq_scale,  (const float *) tensor->op_params +  6, sizeof(float));
              memcpy(&ext_factor,  (const float *) tensor->op_params +  7, sizeof(float));
              memcpy(&attn_factor, (const float *) tensor->op_params +  8, sizeof(float));
              memcpy(&beta_fast,   (const float *) tensor->op_params +  9, sizeof(float));
              memcpy(&beta_slow,   (const float *) tensor->op_params + 10, sizeof(float));
              memcpy(&sections,                    tensor->op_params + 11, sizeof(sections));

              struct ggml_tensor * rope_back = grad->ne[2] == src1->ne[0] ?
                  ggml_rope_ext_back(ctx, grad, src1, src2, n_dims,
                      mode, n_ctx_orig, freq_base, freq_scale, ext_factor, attn_factor, beta_fast, beta_slow) :
                  ggml_rope_multi_back(ctx, grad, src1, src2, n_dims, sections,
                      mode, n_ctx_orig, freq_base, freq_scale, ext_factor, attn_factor, beta_fast, beta_slow);
              ggml_add_or_set(ctx, cgraph, isrc0, rope_back);
          }
          GGML_ASSERT((!src2 || !src2_needs_grads) && "gradients for freq factors not implemented")if (!((!src2 || !src2_needs_grads) && "gradients for freq factors not implemented"
)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6783, "GGML_ASSERT(%s) failed", "(!src2 || !src2_needs_grads) && \"gradients for freq factors not implemented\""
);
      } break;
      case GGML_OP_IM2COL: {
          if (src1_needs_grads) {
              const int32_t s0    = ggml_get_op_params_i32(tensor, 0);
              const int32_t s1    = ggml_get_op_params_i32(tensor, 1);
              const int32_t p0    = ggml_get_op_params_i32(tensor, 2);
              const int32_t p1    = ggml_get_op_params_i32(tensor, 3);
              const int32_t d0    = ggml_get_op_params_i32(tensor, 4);
              const int32_t d1    = ggml_get_op_params_i32(tensor, 5);
              const bool_Bool    is_2D = ggml_get_op_params_i32(tensor, 6) == 1;

              ggml_add_or_set(ctx, cgraph, isrc1, ggml_im2col_back(ctx, grad, src0, src1->ne, s0, s1, p0, p1, d0, d1, is_2D));
          }
      } break;
      case GGML_OP_POOL_2D: {
          if (src0_needs_grads) {
              const enum ggml_op_pool op = ggml_get_op_params_i32(tensor, 0);
              const      int32_t      k0 = ggml_get_op_params_i32(tensor, 1);
              const      int32_t      k1 = ggml_get_op_params_i32(tensor, 2);
              const      int32_t      s0 = ggml_get_op_params_i32(tensor, 3);
              const      int32_t      s1 = ggml_get_op_params_i32(tensor, 4);
              const      int32_t      p0 = ggml_get_op_params_i32(tensor, 5);
              const      int32_t      p1 = ggml_get_op_params_i32(tensor, 6);

              ggml_add_or_set(ctx, cgraph, isrc0, ggml_pool_2d_back(ctx, grad, src0, op, k0, k1, s0, s1, p0, p1));
          }
      } break;
      case GGML_OP_WIN_PART:
      case GGML_OP_WIN_UNPART:
      case GGML_OP_UNARY: {
          switch (ggml_get_unary_op(tensor)) {
              case GGML_UNARY_OP_ABS: {
                  if (src0_needs_grads) {
                      ggml_add_or_set(ctx, cgraph, isrc0, ggml_mul(ctx, ggml_sgn(ctx, src0), grad));
                  }
              } break;
              case GGML_UNARY_OP_SGN: {
                  // noop
              } break;
              case GGML_UNARY_OP_NEG: {
                  if (src0_needs_grads) {
                      ggml_sub_or_set(ctx, cgraph, isrc0, grad);
                  }
              } break;
              case GGML_UNARY_OP_STEP: {
                  // noop
              } break;
              case GGML_UNARY_OP_RELU: {
                  if (src0_needs_grads) {
                      ggml_add_or_set(ctx, cgraph, isrc0, ggml_mul(ctx, ggml_step(ctx, src0), grad));
                  }
              } break;
              case GGML_UNARY_OP_SILU: {
                  if (src0_needs_grads) {
                      ggml_add_or_set(ctx, cgraph, isrc0, ggml_silu_back(ctx, grad, src0));
                  }
              } break;
              case GGML_UNARY_OP_EXP: {
                  if (src0_needs_grads) {
                      ggml_add_or_set(ctx, cgraph, isrc0, ggml_mul(ctx, tensor, grad));
                  }
              } break;
              case GGML_UNARY_OP_EXPM1: {
                  if (src0_needs_grads) {
                      ggml_add_or_set(ctx, cgraph, isrc0, ggml_mul(ctx, grad, ggml_exp(ctx, src0)));
                  }
              } break;
              case GGML_UNARY_OP_SOFTPLUS: {
                  if (src0_needs_grads) {
                      ggml_add_or_set(ctx, cgraph, isrc0, ggml_mul(ctx, grad, ggml_sigmoid(ctx, src0)));
                  }
              } break;
              default: {
                  fprintf(stderrstderr, "%s: unsupported unary op for backward pass: %s\n",
                      __func__, ggml_unary_op_name(ggml_get_unary_op(tensor)));
                  GGML_ABORT("fatal error")ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6859, "fatal error");
              } //break;
          }
      } break;
      case GGML_OP_CROSS_ENTROPY_LOSS: {
          if (src0_needs_grads) {
              ggml_add_or_set(ctx, cgraph, isrc0, ggml_cross_entropy_loss_back(ctx, grad, src0, src1));
          }
          GGML_ASSERT(!src1_needs_grads && "backward pass for labels not implemented")if (!(!src1_needs_grads && "backward pass for labels not implemented"
)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6867, "GGML_ASSERT(%s) failed", "!src1_needs_grads && \"backward pass for labels not implemented\""
);
      } break;
      case GGML_OP_GLU: {
          switch (ggml_get_glu_op(tensor)) {
              case GGML_GLU_OP_SWIGLU: {
                  if (src0_needs_grads) {
                      GGML_ASSERT(src1 && "backward pass only implemented for split swiglu")if (!(src1 && "backward pass only implemented for split swiglu"
)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6873, "GGML_ASSERT(%s) failed", "src1 && \"backward pass only implemented for split swiglu\""
);
                      ggml_add_or_set(ctx, cgraph, isrc0, ggml_silu_back(ctx, ggml_mul(ctx, grad, src1), src0));
                  }
                  if (src1_needs_grads) {
                      ggml_add_or_set(ctx, cgraph, isrc1, ggml_mul(ctx, ggml_silu(ctx, src0), grad));
                  }
              } break;
              default: {
                  GGML_ABORT("unsupported glu op for backward pass: %s", ggml_glu_op_name(ggml_get_glu_op(tensor)))ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6881, "unsupported glu op for backward pass: %s", ggml_glu_op_name
(ggml_get_glu_op(tensor)));
              } //break;
          }
      } break;
      case GGML_OP_NONE: {
          // noop
      } break;
      case GGML_OP_COUNT:
      default: {
          GGML_ABORT("%s: unsupported ggml op for backward pass: %s\n", __func__, ggml_op_name(tensor->op))ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6890, "%s: unsupported ggml op for backward pass: %s\n", __func__
, ggml_op_name(tensor->op));
      } //break;
  }

  GGML_ASSERT(!src0_needs_grads || ggml_are_same_shape(src0, cgraph->grads[isrc0]))if (!(!src0_needs_grads || ggml_are_same_shape(src0, cgraph->
grads[isrc0]))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6894, "GGML_ASSERT(%s) failed", "!src0_needs_grads || ggml_are_same_shape(src0, cgraph->grads[isrc0])"
);
  GGML_ASSERT(!src1_needs_grads || ggml_are_same_shape(src1, cgraph->grads[isrc1]))if (!(!src1_needs_grads || ggml_are_same_shape(src1, cgraph->
grads[isrc1]))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6895, "GGML_ASSERT(%s) failed", "!src1_needs_grads || ggml_are_same_shape(src1, cgraph->grads[isrc1])"
);
  GGML_ASSERT(!src2_needs_grads || ggml_are_same_shape(src2, cgraph->grads[isrc2]))if (!(!src2_needs_grads || ggml_are_same_shape(src2, cgraph->
grads[isrc2]))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6896, "GGML_ASSERT(%s) failed", "!src2_needs_grads || ggml_are_same_shape(src2, cgraph->grads[isrc2])"
);
6897}

6899static size_t ggml_visit_parents_graph(struct ggml_cgraph * cgraph, struct ggml_tensor * node, bool_Bool compute) {
  if (node->op != GGML_OP_NONE && compute) {
      node->flags |= GGML_TENSOR_FLAG_COMPUTE;
  }

  const size_t node_hash_pos = ggml_hash_find(&cgraph->visited_hash_set, node);
  GGML_ASSERT(node_hash_pos != GGML_HASHSET_FULL)if (!(node_hash_pos != ((size_t)-1))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6905, "GGML_ASSERT(%s) failed", "node_hash_pos != GGML_HASHSET_FULL"
);

  if (ggml_bitset_get(cgraph->visited_hash_set.used, node_hash_pos)) {
      // already visited

      if (compute) {
          // update the compute flag regardless
          for (int i = 0; i < GGML_MAX_SRC10; ++i) {
              struct ggml_tensor * src = node->src[i];
              if (src && ((src->flags & GGML_TENSOR_FLAG_COMPUTE) == 0)) {
                  ggml_visit_parents_graph(cgraph, src, true1);
              }
          }
      }

      return node_hash_pos;
  }

  // This is the first time we see this node in the current graph.
  cgraph->visited_hash_set.keys[node_hash_pos] = node;
  ggml_bitset_set(cgraph->visited_hash_set.used, node_hash_pos);
  cgraph->use_counts[node_hash_pos] = 0;

  for (int i = 0; i < GGML_MAX_SRC10; ++i) {
      const int k =
          (cgraph->order == GGML_CGRAPH_EVAL_ORDER_LEFT_TO_RIGHT) ? i :
          (cgraph->order == GGML_CGRAPH_EVAL_ORDER_RIGHT_TO_LEFT) ? (GGML_MAX_SRC10-1-i) :
          /* unknown order, just fall back to using i */ i;

      struct ggml_tensor * src = node->src[k];
      if (src) {
          const size_t src_hash_pos = ggml_visit_parents_graph(cgraph, src, compute);

          // Update the use count for this operand.
          cgraph->use_counts[src_hash_pos]++;
      }
  }

  if (node->op == GGML_OP_NONE && !(node->flags & GGML_TENSOR_FLAG_PARAM)) {
      // reached a leaf node, not part of the gradient graph (e.g. a constant)
      GGML_ASSERT(cgraph->n_leafs < cgraph->size)if (!(cgraph->n_leafs < cgraph->size)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6945, "GGML_ASSERT(%s) failed", "cgraph->n_leafs < cgraph->size"
);

      if (strlen(node->name) == 0) {
          ggml_format_name(node, "leaf_%d", cgraph->n_leafs);
      }

      cgraph->leafs[cgraph->n_leafs] = node;
      cgraph->n_leafs++;
  } else {
      GGML_ASSERT(cgraph->n_nodes < cgraph->size)if (!(cgraph->n_nodes < cgraph->size)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6954, "GGML_ASSERT(%s) failed", "cgraph->n_nodes < cgraph->size"
);

      if (strlen(node->name) == 0) {
          ggml_format_name(node, "node_%d", cgraph->n_nodes);
      }

      cgraph->nodes[cgraph->n_nodes] = node;
      cgraph->n_nodes++;
  }

  return node_hash_pos;
6965}

6967static void ggml_build_forward_impl(struct ggml_cgraph * cgraph, struct ggml_tensor * tensor, bool_Bool expand, bool_Bool compute) {
  if (!expand) {
      // TODO: this branch isn't accessible anymore, maybe move this to ggml_build_forward_expand
      ggml_graph_clear(cgraph);
  }

  const int n_old = cgraph->n_nodes;

  ggml_visit_parents_graph(cgraph, tensor, compute);

  const int n_new = cgraph->n_nodes - n_old;
  GGML_PRINT_DEBUG("%s: visited %d new nodes\n", __func__, n_new);

  if (n_new > 0) {
      // the last added node should always be starting point
      GGML_ASSERT(cgraph->nodes[cgraph->n_nodes - 1] == tensor)if (!(cgraph->nodes[cgraph->n_nodes - 1] == tensor)) ggml_abort
("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6982, "GGML_ASSERT(%s) failed", "cgraph->nodes[cgraph->n_nodes - 1] == tensor"
);
  }
6984}

6986struct ggml_tensor * ggml_build_forward_select(
      struct ggml_cgraph  * cgraph,
      struct ggml_tensor ** tensors,
      int                   n_tensors,
      int                   idx) {
  GGML_ASSERT(idx >= 0 && idx < n_tensors)if (!(idx >= 0 && idx < n_tensors)) ggml_abort(
"/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 6991, "GGML_ASSERT(%s) failed", "idx >= 0 && idx < n_tensors"
);

  for (int i = 0; i < n_tensors; i++) {
      ggml_build_forward_impl(cgraph, tensors[i], true1, i == idx ? true1 : false0);
  }

  return tensors[idx];
6998}

7000void ggml_build_forward_expand(struct ggml_cgraph * cgraph, struct ggml_tensor * tensor) {
  ggml_build_forward_impl(cgraph, tensor, true1, true1);
7002}

7004void ggml_build_backward_expand(
      struct ggml_context *  ctx,
      struct ggml_cgraph  *  cgraph,
      struct ggml_tensor  ** grad_accs) {
  GGML_ASSERT(cgraph->n_nodes > 0)if (!(cgraph->n_nodes > 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7008, "GGML_ASSERT(%s) failed", "cgraph->n_nodes > 0"
);
  GGML_ASSERT(cgraph->grads)if (!(cgraph->grads)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7009, "GGML_ASSERT(%s) failed", "cgraph->grads");
  GGML_ASSERT(cgraph->grad_accs)if (!(cgraph->grad_accs)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7010, "GGML_ASSERT(%s) failed", "cgraph->grad_accs");

  const int n_nodes_f = cgraph->n_nodes;

  memset(cgraph->grads,     0, cgraph->visited_hash_set.size*sizeof(struct ggml_tensor *));
  memset(cgraph->grad_accs, 0, cgraph->visited_hash_set.size*sizeof(struct ggml_tensor *));
  bool_Bool * grads_needed = calloc(cgraph->visited_hash_set.size, sizeof(bool_Bool));

  {
      bool_Bool any_params = false0;
      bool_Bool any_loss   = false0;
      for (int i = 0; i < n_nodes_f; ++i) {
          struct ggml_tensor * node = cgraph->nodes[i];
          any_params = any_params || (node->flags & GGML_TENSOR_FLAG_PARAM);
          any_loss   = any_loss   || (node->flags & GGML_TENSOR_FLAG_LOSS);
      }
      GGML_ASSERT(any_params && "no trainable parameters found, did you forget to call ggml_set_param?")if (!(any_params && "no trainable parameters found, did you forget to call ggml_set_param?"
)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7026, "GGML_ASSERT(%s) failed", "any_params && \"no trainable parameters found, did you forget to call ggml_set_param?\""
);
      GGML_ASSERT(any_loss && "no training loss found, did you forget to call ggml_set_loss?")if (!(any_loss && "no training loss found, did you forget to call ggml_set_loss?"
)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7027, "GGML_ASSERT(%s) failed", "any_loss && \"no training loss found, did you forget to call ggml_set_loss?\""
);
  }

  for (int i = 0; i < n_nodes_f; ++i) {
      struct ggml_tensor * node = cgraph->nodes[i];

      if (node->type == GGML_TYPE_I32) {
          continue;
      }

      bool_Bool node_needs_grad = (node->flags & GGML_TENSOR_FLAG_PARAM) || (node->flags & GGML_TENSOR_FLAG_LOSS);
      bool_Bool ignore_src[GGML_MAX_SRC10] = {false0};
      switch (node->op) {
          // gradients in node->src[0] for one reason or another have no effect on output gradients
          case GGML_OP_IM2COL:      // only used for its shape
          case GGML_OP_IM2COL_BACK: // same as IM2COL
              ignore_src[0] = true1;
              break;
          case GGML_OP_UNARY: {
              const enum ggml_unary_op uop = ggml_get_unary_op(node);
              // SGN and STEP unary ops are piecewise constant
              if (uop == GGML_UNARY_OP_SGN || uop == GGML_UNARY_OP_STEP) {
                  ignore_src[0] = true1;
              }
          } break;

          // gradients in node->src[1] for one reason or another have no effect on output gradients
          case GGML_OP_CPY:           // gradients in CPY target are irrelevant
          case GGML_OP_GET_ROWS:      // row indices not differentiable
          case GGML_OP_GET_ROWS_BACK: // same as for GET_ROWS
          case GGML_OP_ROPE:          // positions not differentiable
              ignore_src[1] = true1;
              break;

          default:
              break;
      }
      for (int j = 0; j < GGML_MAX_SRC10; ++j) {
          if (!node->src[j] || ignore_src[j] || !grads_needed[ggml_hash_find(&cgraph->visited_hash_set, node->src[j])]) {
              continue;
          }
          GGML_ASSERT(node->src[j]->type == GGML_TYPE_F32 || node->src[j]->type == GGML_TYPE_F16)if (!(node->src[j]->type == GGML_TYPE_F32 || node->src
[j]->type == GGML_TYPE_F16)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7068, "GGML_ASSERT(%s) failed", "node->src[j]->type == GGML_TYPE_F32 || node->src[j]->type == GGML_TYPE_F16"
);
          node_needs_grad = true1;
          break;
      }
      if (!node_needs_grad) {
          continue;
      }

      // inplace operations are currently not supported
      GGML_ASSERT(!node->view_src || node->op == GGML_OP_CPY || node->op == GGML_OP_VIEW ||if (!(!node->view_src || node->op == GGML_OP_CPY || node
->op == GGML_OP_VIEW || node->op == GGML_OP_RESHAPE || node
->op == GGML_OP_PERMUTE || node->op == GGML_OP_TRANSPOSE
)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7078, "GGML_ASSERT(%s) failed", "!node->view_src || node->op == GGML_OP_CPY || node->op == GGML_OP_VIEW || node->op == GGML_OP_RESHAPE || node->op == GGML_OP_PERMUTE || node->op == GGML_OP_TRANSPOSE"
)
          node->op == GGML_OP_RESHAPE || node->op == GGML_OP_PERMUTE || node->op == GGML_OP_TRANSPOSE)if (!(!node->view_src || node->op == GGML_OP_CPY || node
->op == GGML_OP_VIEW || node->op == GGML_OP_RESHAPE || node
->op == GGML_OP_PERMUTE || node->op == GGML_OP_TRANSPOSE
)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7078, "GGML_ASSERT(%s) failed", "!node->view_src || node->op == GGML_OP_CPY || node->op == GGML_OP_VIEW || node->op == GGML_OP_RESHAPE || node->op == GGML_OP_PERMUTE || node->op == GGML_OP_TRANSPOSE"
);

      const size_t ihash = ggml_hash_find(&cgraph->visited_hash_set, node);
      GGML_ASSERT(ihash != GGML_HASHSET_FULL)if (!(ihash != ((size_t)-1))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7081, "GGML_ASSERT(%s) failed", "ihash != GGML_HASHSET_FULL"
);
      GGML_ASSERT(ggml_bitset_get(cgraph->visited_hash_set.used, ihash))if (!(ggml_bitset_get(cgraph->visited_hash_set.used, ihash
))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7082, "GGML_ASSERT(%s) failed", "ggml_bitset_get(cgraph->visited_hash_set.used, ihash)"
);
      if (grad_accs && grad_accs[i]) {
          cgraph->grad_accs[ihash] = grad_accs[i];
          cgraph->grads[ihash]     = cgraph->grad_accs[ihash];
      } else if (node->flags & GGML_TENSOR_FLAG_LOSS) {
          // loss tensors always need a gradient accumulator
          cgraph->grad_accs[ihash] = ggml_new_tensor(ctx, GGML_TYPE_F32, GGML_MAX_DIMS4, node->ne);
          cgraph->grads[ihash]     = cgraph->grad_accs[ihash];
      }
      grads_needed[ihash] = true1;
  }

  for (int i = n_nodes_f - 1; i >= 0; --i) {
      // inplace operations to add gradients are not created by ggml_compute_backward except for gradient accumulation
      // use allocator to automatically make inplace operations
      ggml_compute_backward(ctx, cgraph, i, grads_needed);
  }

  free(grads_needed);
7101}

7103static void * incr_ptr_aligned(void ** p, size_t size, size_t align) {
  void * ptr = *p;
  ptr = (void *) GGML_PAD((uintptr_t) ptr, align)((((uintptr_t) ptr) + (align) - 1) & ~((align) - 1));
  *p = (void *) ((char *) ptr + size);
  return ptr;
7108}

7110static size_t ggml_graph_nbytes(size_t size, bool_Bool grads) {
  size_t hash_size = ggml_hash_size(size * 2);
  void * p = 0;
  incr_ptr_aligned(&p, sizeof(struct ggml_cgraph), 1);
  incr_ptr_aligned(&p, size * sizeof(struct ggml_tensor *), sizeof(struct ggml_tensor *)); // nodes
  incr_ptr_aligned(&p, size * sizeof(struct ggml_tensor *), sizeof(struct ggml_tensor *)); // leafs
  incr_ptr_aligned(&p, hash_size * sizeof(int32_t), sizeof(int32_t)); // use_counts
  incr_ptr_aligned(&p, hash_size * sizeof(struct ggml_tensor *), sizeof(struct ggml_tensor *)); // hash keys
  if (grads) {
      incr_ptr_aligned(&p, hash_size * sizeof(struct ggml_tensor *), sizeof(struct ggml_tensor *)); // grads
      incr_ptr_aligned(&p, hash_size * sizeof(struct ggml_tensor *), sizeof(struct ggml_tensor *)); // grad_accs
  }
  incr_ptr_aligned(&p, ggml_bitset_size(hash_size) * sizeof(ggml_bitset_t), sizeof(ggml_bitset_t));

  size_t nbytes = (size_t) p;
  return nbytes;
7126}

7128size_t ggml_graph_overhead_custom(size_t size, bool_Bool grads) {
  return GGML_OBJECT_SIZE + GGML_PAD(ggml_graph_nbytes(size, grads), GGML_MEM_ALIGN)(((ggml_graph_nbytes(size, grads)) + (16) - 1) & ~((16) -
 1));
7130}

7132size_t ggml_graph_overhead(void) {
  return ggml_graph_overhead_custom(GGML_DEFAULT_GRAPH_SIZE2048, false0);
7134}

7136struct ggml_cgraph * ggml_new_graph_custom(struct ggml_context * ctx, size_t size, bool_Bool grads) {
  const size_t obj_size = ggml_graph_nbytes(size, grads);
  struct ggml_object * obj = ggml_new_object(ctx, GGML_OBJECT_TYPE_GRAPH, obj_size);
  struct ggml_cgraph * cgraph = (struct ggml_cgraph *) ((char *) ctx->mem_buffer + obj->offs);

  // the size of the hash table is doubled since it needs to hold both nodes and leafs
  size_t hash_size = ggml_hash_size(size * 2);

  void * p = cgraph + 1;

  struct ggml_tensor ** nodes_ptr      =         incr_ptr_aligned(&p, size      * sizeof(struct ggml_tensor *), sizeof(struct ggml_tensor *));
  struct ggml_tensor ** leafs_ptr      =         incr_ptr_aligned(&p, size      * sizeof(struct ggml_tensor *), sizeof(struct ggml_tensor *));
  int32_t             * use_counts_ptr =         incr_ptr_aligned(&p, hash_size * sizeof(int32_t), sizeof(int32_t));
  struct ggml_tensor ** hash_keys_ptr  =         incr_ptr_aligned(&p, hash_size * sizeof(struct ggml_tensor *), sizeof(struct ggml_tensor *));
  struct ggml_tensor ** grads_ptr      = grads ? incr_ptr_aligned(&p, hash_size * sizeof(struct ggml_tensor *), sizeof(struct ggml_tensor *)) : NULL((void*)0);
  struct ggml_tensor ** grad_accs_ptr  = grads ? incr_ptr_aligned(&p, hash_size * sizeof(struct ggml_tensor *), sizeof(struct ggml_tensor *)) : NULL((void*)0);

  ggml_bitset_t * hash_used = incr_ptr_aligned(&p, ggml_bitset_size(hash_size) * sizeof(ggml_bitset_t), sizeof(ggml_bitset_t));

  // check that we allocated the correct amount of memory
  assert(obj_size == (size_t)((char *)p - (char *)cgraph))((void) sizeof (__assert_single_arg (obj_size == (size_t)((char
 *)p - (char *)cgraph))), __extension__ ({ if (obj_size == (size_t
)((char *)p - (char *)cgraph)) ; else __assert_fail ("obj_size == (size_t)((char *)p - (char *)cgraph)"
, "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7156, __extension__ __PRETTY_FUNCTION__); }));

  *cgraph = (struct ggml_cgraph) {
      /*.size         =*/ size,
      /*.n_nodes      =*/ 0,
      /*.n_leafs      =*/ 0,
      /*.nodes        =*/ nodes_ptr,
      /*.grads        =*/ grads_ptr,
      /*.grad_accs    =*/ grad_accs_ptr,
      /*.leafs        =*/ leafs_ptr,
      /*.use_counts   =*/ use_counts_ptr,
      /*.hash_table   =*/ { hash_size, hash_used, hash_keys_ptr },
      /*.order        =*/ GGML_CGRAPH_EVAL_ORDER_LEFT_TO_RIGHT,
      /*.uid          =*/ 0,
  };

  ggml_hash_set_reset(&cgraph->visited_hash_set);
  if (grads) {
      memset(cgraph->grads,     0, hash_size*sizeof(struct ggml_tensor *));
      memset(cgraph->grad_accs, 0, hash_size*sizeof(struct ggml_tensor *));
  }

  return cgraph;
7179}

7181struct ggml_cgraph * ggml_new_graph(struct ggml_context * ctx) {
  return ggml_new_graph_custom(ctx, GGML_DEFAULT_GRAPH_SIZE2048, false0);
7183}

7185struct ggml_cgraph ggml_graph_view(struct ggml_cgraph * cgraph0, int i0, int i1) {
  struct ggml_cgraph cgraph = {
      /*.size             =*/ 0,
      /*.n_nodes          =*/ i1 - i0,
      /*.n_leafs          =*/ 0,
      /*.nodes            =*/ cgraph0->nodes + i0,
      /*.grads            =*/ NULL((void*)0), // gradients would need visited_hash_set
      /*.grad_accs        =*/ NULL((void*)0),
      /*.leafs            =*/ NULL((void*)0),
      /*.use_counts       =*/ cgraph0->use_counts,
      /*.visited_hash_set =*/ cgraph0->visited_hash_set,
      /*.order            =*/ cgraph0->order,
      /*.uid              =*/ 0
  };

  return cgraph;
7201}

7203void ggml_graph_cpy(struct ggml_cgraph * src, struct ggml_cgraph * dst) {
  GGML_ASSERT(dst->size >= src->n_leafs)if (!(dst->size >= src->n_leafs)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7204, "GGML_ASSERT(%s) failed", "dst->size >= src->n_leafs"
);
  GGML_ASSERT(dst->size >= src->n_nodes)if (!(dst->size >= src->n_nodes)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7205, "GGML_ASSERT(%s) failed", "dst->size >= src->n_nodes"
);
  GGML_ASSERT(dst->visited_hash_set.size >= src->visited_hash_set.size)if (!(dst->visited_hash_set.size >= src->visited_hash_set
.size)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7206, "GGML_ASSERT(%s) failed", "dst->visited_hash_set.size >= src->visited_hash_set.size"
);

  dst->n_leafs = src->n_leafs;
  dst->n_nodes = src->n_nodes;
  dst->order   = src->order;

  for (int i = 0; i < src->n_leafs; ++i) {
      dst->leafs[i] = src->leafs[i];
  }

  for (int i = 0; i < src->n_nodes; ++i) {
      dst->nodes[i] = src->nodes[i];
  }

  for (size_t i = 0; i < src->visited_hash_set.size; ++i) {
      // copy all hashset keys (tensors) that are in use
      if (ggml_bitset_get(src->visited_hash_set.used, i)) {
          size_t new_hash_pos = ggml_hash_insert(&dst->visited_hash_set, src->visited_hash_set.keys[i]);
          dst->use_counts[new_hash_pos] = src->use_counts[i];
      }
  }

  if (dst->grads) {
      memset(dst->grads,     0, dst->visited_hash_set.size*sizeof(struct ggml_tensor *));
      memset(dst->grad_accs, 0, dst->visited_hash_set.size*sizeof(struct ggml_tensor *));
  }
  if (src->grads) {
      GGML_ASSERT(dst->grads     != NULL)if (!(dst->grads != ((void*)0))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7233, "GGML_ASSERT(%s) failed", "dst->grads != NULL");
      GGML_ASSERT(dst->grad_accs != NULL)if (!(dst->grad_accs != ((void*)0))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7234, "GGML_ASSERT(%s) failed", "dst->grad_accs != NULL"
);
      for (int i = 0; i < src->n_nodes; ++i) {
          const size_t igrad_src = ggml_hash_find(&src->visited_hash_set, src->nodes[i]);
          const size_t igrad_dst = ggml_hash_find(&dst->visited_hash_set, dst->nodes[i]);

          GGML_ASSERT(igrad_src != GGML_HASHSET_FULL)if (!(igrad_src != ((size_t)-1))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7239, "GGML_ASSERT(%s) failed", "igrad_src != GGML_HASHSET_FULL"
);
          GGML_ASSERT(ggml_bitset_get(src->visited_hash_set.used, igrad_src))if (!(ggml_bitset_get(src->visited_hash_set.used, igrad_src
))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7240, "GGML_ASSERT(%s) failed", "ggml_bitset_get(src->visited_hash_set.used, igrad_src)"
);
          GGML_ASSERT(igrad_dst != GGML_HASHSET_FULL)if (!(igrad_dst != ((size_t)-1))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7241, "GGML_ASSERT(%s) failed", "igrad_dst != GGML_HASHSET_FULL"
);
          GGML_ASSERT(ggml_bitset_get(dst->visited_hash_set.used, igrad_dst))if (!(ggml_bitset_get(dst->visited_hash_set.used, igrad_dst
))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7242, "GGML_ASSERT(%s) failed", "ggml_bitset_get(dst->visited_hash_set.used, igrad_dst)"
);

          dst->grads[igrad_dst]     = src->grads[igrad_src];
          dst->grad_accs[igrad_dst] = src->grad_accs[igrad_src];
      }
  }
7248}

7250struct ggml_cgraph * ggml_graph_dup(struct ggml_context * ctx, struct ggml_cgraph * cgraph, bool_Bool force_grads) {
  struct ggml_cgraph * result = ggml_new_graph_custom(ctx, cgraph->size, cgraph->grads || force_grads);
  ggml_graph_cpy(cgraph, result);
  return result;
7254}

7256struct ggml_tensor * ggml_set_zero(struct ggml_tensor * tensor) {
  if (ggml_is_empty(tensor)) {
      return tensor;
  }
  if (tensor->buffer) {
      ggml_backend_tensor_memset(tensor, 0, 0, ggml_nbytes(tensor));
  } else {
      GGML_ASSERT(tensor->data)if (!(tensor->data)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7263, "GGML_ASSERT(%s) failed", "tensor->data");
      memset(tensor->data, 0, ggml_nbytes(tensor));
  }
  return tensor;
7267}

7269void ggml_graph_reset(struct ggml_cgraph * cgraph) {
  if (!cgraph) {
      return;
  }
  GGML_ASSERT(cgraph->grads != NULL)if (!(cgraph->grads != ((void*)0))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7273, "GGML_ASSERT(%s) failed", "cgraph->grads != NULL");

  for (int i = 0; i < cgraph->n_nodes; i++) {
      struct ggml_tensor * node     = cgraph->nodes[i];
      struct ggml_tensor * grad_acc = ggml_graph_get_grad_acc(cgraph, node);

      if (node->op == GGML_OP_OPT_STEP_ADAMW) {
          // clear momenta
          ggml_set_zero(node->src[2]);
          ggml_set_zero(node->src[3]);
      }

      // initial gradients of loss should be 1, 0 otherwise
      if (grad_acc) {
          if (node->flags & GGML_TENSOR_FLAG_LOSS) {
              GGML_ASSERT(grad_acc->type == GGML_TYPE_F32)if (!(grad_acc->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7288, "GGML_ASSERT(%s) failed", "grad_acc->type == GGML_TYPE_F32"
);
              GGML_ASSERT(ggml_is_scalar(grad_acc))if (!(ggml_is_scalar(grad_acc))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7289, "GGML_ASSERT(%s) failed", "ggml_is_scalar(grad_acc)");

              const float onef = 1.0f;
              if (grad_acc->buffer) {
                  ggml_backend_tensor_set(grad_acc, &onef, 0, sizeof(float));
              } else {
                  GGML_ASSERT(grad_acc->data)if (!(grad_acc->data)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7295, "GGML_ASSERT(%s) failed", "grad_acc->data");
                  *((float *) grad_acc->data) = onef;
              }
          } else {
              ggml_set_zero(grad_acc);
          }
      }
  }
7303}

7305void ggml_graph_clear(struct ggml_cgraph * cgraph) {
  cgraph->n_leafs = 0;
  cgraph->n_nodes = 0;
  ggml_hash_set_reset(&cgraph->visited_hash_set);
7309}

7311int ggml_graph_size(struct ggml_cgraph * cgraph) {
  return cgraph->size;
7313}

7315struct ggml_tensor * ggml_graph_node(struct ggml_cgraph * cgraph, int i) {
  if (i < 0) {
      GGML_ASSERT(cgraph->n_nodes + i >= 0)if (!(cgraph->n_nodes + i >= 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7317, "GGML_ASSERT(%s) failed", "cgraph->n_nodes + i >= 0"
);
      return cgraph->nodes[cgraph->n_nodes + i];
  }

  GGML_ASSERT(i < cgraph->n_nodes)if (!(i < cgraph->n_nodes)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7321, "GGML_ASSERT(%s) failed", "i < cgraph->n_nodes"
);
  return cgraph->nodes[i];
7323}

7325struct ggml_tensor ** ggml_graph_nodes(struct ggml_cgraph * cgraph) {
  return cgraph->nodes;
7327}

7329int ggml_graph_n_nodes(struct ggml_cgraph * cgraph) {
  return cgraph->n_nodes;
7331}

7333void ggml_graph_add_node(struct ggml_cgraph * cgraph, struct ggml_tensor * tensor) {
  GGML_ASSERT(cgraph->size > cgraph->n_nodes)if (!(cgraph->size > cgraph->n_nodes)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7334, "GGML_ASSERT(%s) failed", "cgraph->size > cgraph->n_nodes"
);
  cgraph->nodes[cgraph->n_nodes] = tensor;
  cgraph->n_nodes++;
7337}

7339struct ggml_tensor * ggml_graph_get_tensor(const struct ggml_cgraph * cgraph, const char * name) {
  for (int i = 0; i < cgraph->n_leafs; i++) {
      struct ggml_tensor * leaf = cgraph->leafs[i];

      if (strcmp(leaf->name, name) == 0) {
          return leaf;
      }
  }

  for (int i = 0; i < cgraph->n_nodes; i++) {
      struct ggml_tensor * node = cgraph->nodes[i];

      if (strcmp(node->name, name) == 0) {
          return node;
      }
  }

  return NULL((void*)0);
7357}

7359struct ggml_tensor * ggml_graph_get_grad(const struct ggml_cgraph * cgraph, const struct ggml_tensor * node) {
  const size_t igrad = ggml_hash_find(&cgraph->visited_hash_set, node);
  return igrad != GGML_HASHSET_FULL((size_t)-1) && ggml_bitset_get(cgraph->visited_hash_set.used, igrad) && cgraph->grads ? cgraph->grads[igrad] : NULL((void*)0);
7362}

7364struct ggml_tensor * ggml_graph_get_grad_acc(const struct ggml_cgraph * cgraph, const struct ggml_tensor * node) {
  const size_t igrad = ggml_hash_find(&cgraph->visited_hash_set, node);
  return igrad != GGML_HASHSET_FULL((size_t)-1) && ggml_bitset_get(cgraph->visited_hash_set.used, igrad) && cgraph->grad_accs ? cgraph->grad_accs[igrad] : NULL((void*)0);
7367}

7369void ggml_graph_print(const struct ggml_cgraph * cgraph) {
  GGML_LOG_INFO("=== GRAPH ===\n")ggml_log_internal(GGML_LOG_LEVEL_INFO , "=== GRAPH ===\n");

  GGML_LOG_INFO("n_nodes = %d\n", cgraph->n_nodes)ggml_log_internal(GGML_LOG_LEVEL_INFO , "n_nodes = %d\n", cgraph
->n_nodes);
  for (int i = 0; i < cgraph->n_nodes; i++) {
      struct ggml_tensor * node = cgraph->nodes[i];

      GGML_LOG_INFO(" - %3d: [ %5" PRId64 ", %5" PRId64 ", %5" PRId64 "] %16s %s\n",ggml_log_internal(GGML_LOG_LEVEL_INFO , " - %3d: [ %5" "l" "d"
 ", %5" "l" "d" ", %5" "l" "d" "] %16s %s\n", i, node->ne[
0], node->ne[1], node->ne[2], ggml_op_name(node->op)
, (node->flags & GGML_TENSOR_FLAG_PARAM) ? "x" : ggml_graph_get_grad
(cgraph, node) ? "g" : " ")
              i,ggml_log_internal(GGML_LOG_LEVEL_INFO , " - %3d: [ %5" "l" "d"
 ", %5" "l" "d" ", %5" "l" "d" "] %16s %s\n", i, node->ne[
0], node->ne[1], node->ne[2], ggml_op_name(node->op)
, (node->flags & GGML_TENSOR_FLAG_PARAM) ? "x" : ggml_graph_get_grad
(cgraph, node) ? "g" : " ")
              node->ne[0], node->ne[1], node->ne[2],ggml_log_internal(GGML_LOG_LEVEL_INFO , " - %3d: [ %5" "l" "d"
 ", %5" "l" "d" ", %5" "l" "d" "] %16s %s\n", i, node->ne[
0], node->ne[1], node->ne[2], ggml_op_name(node->op)
, (node->flags & GGML_TENSOR_FLAG_PARAM) ? "x" : ggml_graph_get_grad
(cgraph, node) ? "g" : " ")
              ggml_op_name(node->op), (node->flags & GGML_TENSOR_FLAG_PARAM) ? "x" :ggml_log_internal(GGML_LOG_LEVEL_INFO , " - %3d: [ %5" "l" "d"
 ", %5" "l" "d" ", %5" "l" "d" "] %16s %s\n", i, node->ne[
0], node->ne[1], node->ne[2], ggml_op_name(node->op)
, (node->flags & GGML_TENSOR_FLAG_PARAM) ? "x" : ggml_graph_get_grad
(cgraph, node) ? "g" : " ")
                    ggml_graph_get_grad(cgraph, node) ? "g" : " ")ggml_log_internal(GGML_LOG_LEVEL_INFO , " - %3d: [ %5" "l" "d"
 ", %5" "l" "d" ", %5" "l" "d" "] %16s %s\n", i, node->ne[
0], node->ne[1], node->ne[2], ggml_op_name(node->op)
, (node->flags & GGML_TENSOR_FLAG_PARAM) ? "x" : ggml_graph_get_grad
(cgraph, node) ? "g" : " ");
  }

  GGML_LOG_INFO("n_leafs = %d\n", cgraph->n_leafs)ggml_log_internal(GGML_LOG_LEVEL_INFO , "n_leafs = %d\n", cgraph
->n_leafs);
  for (int i = 0; i < cgraph->n_leafs; i++) {
      struct ggml_tensor * node = cgraph->leafs[i];

      GGML_LOG_INFO(" - %3d: [ %5" PRId64 ", %5" PRId64 "] %8s %16s\n",ggml_log_internal(GGML_LOG_LEVEL_INFO , " - %3d: [ %5" "l" "d"
 ", %5" "l" "d" "] %8s %16s\n", i, node->ne[0], node->ne
[1], ggml_op_name(node->op), ggml_get_name(node))
              i,ggml_log_internal(GGML_LOG_LEVEL_INFO , " - %3d: [ %5" "l" "d"
 ", %5" "l" "d" "] %8s %16s\n", i, node->ne[0], node->ne
[1], ggml_op_name(node->op), ggml_get_name(node))
              node->ne[0], node->ne[1],ggml_log_internal(GGML_LOG_LEVEL_INFO , " - %3d: [ %5" "l" "d"
 ", %5" "l" "d" "] %8s %16s\n", i, node->ne[0], node->ne
[1], ggml_op_name(node->op), ggml_get_name(node))
              ggml_op_name(node->op),ggml_log_internal(GGML_LOG_LEVEL_INFO , " - %3d: [ %5" "l" "d"
 ", %5" "l" "d" "] %8s %16s\n", i, node->ne[0], node->ne
[1], ggml_op_name(node->op), ggml_get_name(node))
              ggml_get_name(node))ggml_log_internal(GGML_LOG_LEVEL_INFO , " - %3d: [ %5" "l" "d"
 ", %5" "l" "d" "] %8s %16s\n", i, node->ne[0], node->ne
[1], ggml_op_name(node->op), ggml_get_name(node));
  }

  GGML_LOG_INFO("========================================\n")ggml_log_internal(GGML_LOG_LEVEL_INFO , "========================================\n"
);
7395}

7397static int ggml_node_list_find_tensor(const struct ggml_cgraph * cgraph,
                                    const int *                idxs,
                                    int                        count,
                                    const struct ggml_tensor * tensor) {
  GGML_ASSERT(cgraph && idxs)if (!(cgraph && idxs)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7401, "GGML_ASSERT(%s) failed", "cgraph && idxs");
  for (int i = 0; i < count; ++i) {
      const int node_idx = idxs[i];

      if (node_idx >= cgraph->n_nodes) {
          return -1;
      }
      if (cgraph->nodes[node_idx] == tensor) {
          return i;
      }
  }
  return -1;
7413}

7415bool_Bool ggml_can_fuse_subgraph_ext(const struct ggml_cgraph * cgraph,
                              const int *                node_idxs,
                              int                        count,
                              const enum ggml_op *       ops,
                              const int *                outputs,
                              int                        num_outputs) {
  GGML_ASSERT(outputs && num_outputs > 0)if (!(outputs && num_outputs > 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7421, "GGML_ASSERT(%s) failed", "outputs && num_outputs > 0"
);

  for (int i = 0; i < count; ++i) {
      if (node_idxs[i] >= cgraph->n_nodes) {
          return false0;
      }

      const struct ggml_tensor * node = cgraph->nodes[node_idxs[i]];

      if (node->op != ops[i]) {
          return false0;
      }

      if ((node->flags & GGML_TENSOR_FLAG_COMPUTE) == 0) {
          return false0;
      }

      if (ggml_node_list_find_tensor(cgraph, outputs, num_outputs, node) != -1) {
          continue;
      }

      if (node->flags & GGML_TENSOR_FLAG_OUTPUT) {
          return false0;
      }

      int subgraph_uses = 0;
      for (int j = i + 1; j < count; ++j) {
          const struct ggml_tensor * other_node = cgraph->nodes[node_idxs[j]];
          for (int src_idx = 0; src_idx < GGML_MAX_SRC10; src_idx++) {
              if (other_node->src[src_idx] == node) {
                  subgraph_uses++;
              }
          }
      }

      if (subgraph_uses != ggml_node_get_use_count(cgraph, node_idxs[i])) {
          return false0;
      }

      // if node is a view, check if the view_src and all it's parent view_srcs are within the subgraph
      struct ggml_tensor * view_src = node->view_src;
      while (view_src) {
          if (ggml_node_list_find_tensor(cgraph, node_idxs, count, view_src) == -1) {
              return false0;
          }
          view_src = view_src->view_src;
      }
  }

  return true1;
7471}

7473// check if node is part of the graph
7474static bool_Bool ggml_graph_find(const struct ggml_cgraph * cgraph, const struct ggml_tensor * node) {
  if (cgraph == NULL((void*)0)) {
      return true1;
  }

  for (int i = 0; i < cgraph->n_nodes; i++) {
      if (cgraph->nodes[i] == node) {
          return true1;
      }
  }

  return false0;
7486}

7488static struct ggml_tensor * ggml_graph_get_parent(const struct ggml_cgraph * cgraph, const struct ggml_tensor * node) {
  for (int i = 0; i < cgraph->n_nodes; i++) {
      struct ggml_tensor * parent = cgraph->nodes[i];
      struct ggml_tensor * grad = ggml_graph_get_grad(cgraph, parent);

      if (grad == node) {
          return parent;
      }
  }

  return NULL((void*)0);
7499}

7501static void ggml_graph_dump_dot_node_edge(FILE * fp, const struct ggml_cgraph * gb, struct ggml_tensor * node, struct ggml_tensor * parent, const char * label)  {
  struct ggml_tensor * gparent = ggml_graph_get_parent(gb, node);
  struct ggml_tensor * gparent0 = ggml_graph_get_parent(gb, parent);
  fprintf(fp, "  \"%p\" -> \"%p\" [ arrowhead = %s; style = %s; label = \"%s\"; ]\n",
          gparent0 ? (void *) gparent0 : (void *) parent,
          gparent ? (void *) gparent : (void *) node,
          gparent ? "empty" : "vee",
          gparent ? "dashed" : "solid",
          label);
7510}

7512static void ggml_graph_dump_dot_leaf_edge(FILE * fp, struct ggml_tensor * node, struct ggml_tensor * parent, const char * label)  {
  fprintf(fp, "  \"%p\" -> \"%p\" [ label = \"%s\"; ]\n",
          (void *) parent,
          (void *) node,
          label);
7517}

7519void ggml_graph_dump_dot(const struct ggml_cgraph * gb, const struct ggml_cgraph * cgraph, const char * filename) {
  char color[16];

  FILE * fp = ggml_fopen(filename, "w");
  GGML_ASSERT(fp)if (!(fp)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7523, "GGML_ASSERT(%s) failed", "fp");

  fprintf(fp, "digraph G {\n");
  fprintf(fp, "  newrank = true;\n");
  fprintf(fp, "  rankdir = TB;\n");

  for (int i = 0; i < gb->n_nodes; i++) {
      struct ggml_tensor * node = gb->nodes[i];
      struct ggml_tensor * grad = ggml_graph_get_grad(gb, node);

      if (ggml_graph_get_parent(gb, node) != NULL((void*)0)) {
          continue;
      }

      if (node->flags & GGML_TENSOR_FLAG_PARAM) {
          snprintf(color, sizeof(color), "yellow");
      } else if (grad) {
          if (ggml_graph_find(cgraph, node)) {
              snprintf(color, sizeof(color), "green");
          } else {
              snprintf(color, sizeof(color), "lightblue");
          }
      } else {
          snprintf(color, sizeof(color), "white");
      }

      fprintf(fp, "  \"%p\" [ "
                  "style = filled; fillcolor = %s; shape = record; "
                  "label=\"",
              (void *) node, color);

      if (strlen(node->name) > 0) {
          fprintf(fp, "%s (%s)|", node->name, ggml_type_name(node->type));
      } else {
          fprintf(fp, "(%s)|", ggml_type_name(node->type));
      }

      if (ggml_is_matrix(node)) {
          fprintf(fp, "%d [%" PRId64"l" "d" ", %" PRId64"l" "d" "] | <x>%s", i, node->ne[0], node->ne[1], ggml_op_symbol(node->op));
      } else {
          fprintf(fp, "%d [%" PRId64"l" "d" ", %" PRId64"l" "d" ", %" PRId64"l" "d" "] | <x>%s", i, node->ne[0], node->ne[1], node->ne[2], ggml_op_symbol(node->op));
      }

      if (grad) {
          fprintf(fp, " | <g>%s\"; ]\n", ggml_op_symbol(grad->op));
      } else {
          fprintf(fp, "\"; ]\n");
      }
  }

  for (int i = 0; i < gb->n_leafs; i++) {
      struct ggml_tensor * node = gb->leafs[i];

      snprintf(color, sizeof(color), "pink");

      fprintf(fp, "  \"%p\" [ "
                  "style = filled; fillcolor = %s; shape = record; "
                  "label=\"<x>",
              (void *) node, color);

      if (strlen(node->name) > 0) {
          fprintf(fp, "%s (%s)|", node->name, ggml_type_name(node->type));
      } else {
          fprintf(fp, "(%s)|", ggml_type_name(node->type));
      }

      fprintf(fp, "CONST %d [%" PRId64"l" "d" ", %" PRId64"l" "d" "]", i, node->ne[0], node->ne[1]);
      if (ggml_nelements(node) < 5 && node->data != NULL((void*)0)) {
          fprintf(fp, " | (");
          for (int j = 0; j < ggml_nelements(node); j++) {
              // FIXME: use ggml-backend to obtain the tensor data
              //if (node->type == GGML_TYPE_I8 || node->type == GGML_TYPE_I16 || node->type == GGML_TYPE_I32) {
              //    fprintf(fp, "%d", ggml_get_i32_1d(node, j));
              //}
              //else if (node->type == GGML_TYPE_F32 ||
              //         node->type == GGML_TYPE_F16 ||
              //         node->type == GGML_TYPE_BF16) {
              //    fprintf(fp, "%.1e", (double)ggml_get_f32_1d(node, j));
              //}
              //else
              {
                  fprintf(fp, "#");
              }
              if (j < ggml_nelements(node) - 1) {
                  fprintf(fp, ", ");
              }
          }
          fprintf(fp, ")");
      }
      fprintf(fp, "\"; ]\n");
  }

  for (int i = 0; i < gb->n_nodes; i++) {
      struct ggml_tensor * node = gb->nodes[i];

      for (int j = 0; j < GGML_MAX_SRC10; j++) {
          if (node->src[j]) {
              char label[16];
              snprintf(label, sizeof(label), "src %d", j);
              ggml_graph_dump_dot_node_edge(fp, gb, node, node->src[j], label);
          }
      }
  }

  for (int i = 0; i < gb->n_leafs; i++) {
      struct ggml_tensor * node = gb->leafs[i];

      for (int j = 0; j < GGML_MAX_SRC10; j++) {
          if (node->src[j]) {
              char label[16];
              snprintf(label, sizeof(label), "src %d", j);
              ggml_graph_dump_dot_leaf_edge(fp, node, node->src[j], label);
          }
      }
  }

  fprintf(fp, "}\n");

  fclose(fp);

  GGML_LOG_INFO("%s: dot -Tpng %s -o %s.png && open %s.png\n", __func__, filename, filename, filename)ggml_log_internal(GGML_LOG_LEVEL_INFO , "%s: dot -Tpng %s -o %s.png && open %s.png\n"
, __func__, filename, filename, filename);
7644}

7646////////////////////////////////////////////////////////////////////////////////

7648void ggml_set_input(struct ggml_tensor * tensor) {
  tensor->flags |= GGML_TENSOR_FLAG_INPUT;
7650}

7652void ggml_set_output(struct ggml_tensor * tensor) {
  tensor->flags |= GGML_TENSOR_FLAG_OUTPUT;
7654}

7656void ggml_set_param(struct ggml_tensor * tensor) {
  GGML_ASSERT(tensor->op == GGML_OP_NONE)if (!(tensor->op == GGML_OP_NONE)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7657, "GGML_ASSERT(%s) failed", "tensor->op == GGML_OP_NONE"
);
  tensor->flags |= GGML_TENSOR_FLAG_PARAM;
7659}

7661void ggml_set_loss(struct ggml_tensor * tensor) {
  GGML_ASSERT(ggml_is_scalar(tensor))if (!(ggml_is_scalar(tensor))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7662, "GGML_ASSERT(%s) failed", "ggml_is_scalar(tensor)");
  GGML_ASSERT(tensor->type == GGML_TYPE_F32)if (!(tensor->type == GGML_TYPE_F32)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7663, "GGML_ASSERT(%s) failed", "tensor->type == GGML_TYPE_F32"
);
  tensor->flags |= GGML_TENSOR_FLAG_LOSS;
7665}

7667////////////////////////////////////////////////////////////////////////////////

7669void ggml_quantize_init(enum ggml_type type) {
  ggml_critical_section_start();

  switch (type) {
      case GGML_TYPE_IQ2_XXS:
      case GGML_TYPE_IQ2_XS:
      case GGML_TYPE_IQ2_S:
      case GGML_TYPE_IQ1_S:
      case GGML_TYPE_IQ1_M:   iq2xs_init_impl(type); break;
      case GGML_TYPE_IQ3_XXS: iq3xs_init_impl(256); break;
      case GGML_TYPE_IQ3_S:   iq3xs_init_impl(512); break;
      default: // nothing
          break;
  }

  ggml_critical_section_end();
7685}

7687void ggml_quantize_free(void) {
  ggml_critical_section_start();

  iq2xs_free_impl(GGML_TYPE_IQ2_XXS);
  iq2xs_free_impl(GGML_TYPE_IQ2_XS);
  iq2xs_free_impl(GGML_TYPE_IQ2_S);
  iq2xs_free_impl(GGML_TYPE_IQ1_S);
  iq2xs_free_impl(GGML_TYPE_IQ1_M);
  iq3xs_free_impl(256);
  iq3xs_free_impl(512);

  ggml_critical_section_end();
7699}

7701bool_Bool ggml_quantize_requires_imatrix(enum ggml_type type) {
  return
      type == GGML_TYPE_IQ2_XXS ||
      type == GGML_TYPE_IQ2_XS  ||
      type == GGML_TYPE_IQ1_S;//   ||
      //type == GGML_TYPE_IQ1_M;
7707}

7709size_t ggml_quantize_chunk(
      enum ggml_type   type,
         const float * src,
                void * dst,
             int64_t   start,
             int64_t   nrows,
             int64_t   n_per_row,
         const float * imatrix) {
  const int64_t n = nrows * n_per_row;

  if (ggml_quantize_requires_imatrix(type)) {
      GGML_ASSERT(imatrix != NULL)if (!(imatrix != ((void*)0))) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7720, "GGML_ASSERT(%s) failed", "imatrix != NULL");
  }

  GGML_ASSERT(start % type_traits[type].blck_size == 0)if (!(start % type_traits[type].blck_size == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7723, "GGML_ASSERT(%s) failed", "start % type_traits[type].blck_size == 0"
);
  GGML_ASSERT(start % n_per_row == 0)if (!(start % n_per_row == 0)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7724, "GGML_ASSERT(%s) failed", "start % n_per_row == 0");

  ggml_quantize_init(type); // this is noop if already initialized

  const size_t start_row = start / n_per_row;
  const size_t row_size  = ggml_row_size(type, n_per_row);

  size_t result = 0;

  switch (type) {
      case GGML_TYPE_Q1_0:    result = quantize_q1_0   (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_Q4_0:    result = quantize_q4_0   (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_Q4_1:    result = quantize_q4_1   (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_Q5_0:    result = quantize_q5_0   (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_Q5_1:    result = quantize_q5_1   (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_Q8_0:    result = quantize_q8_0   (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_MXFP4:   result = quantize_mxfp4  (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_NVFP4:   result = quantize_nvfp4  (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_Q2_K:    result = quantize_q2_K   (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_Q3_K:    result = quantize_q3_K   (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_Q4_K:    result = quantize_q4_K   (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_Q5_K:    result = quantize_q5_K   (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_Q6_K:    result = quantize_q6_K   (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_TQ1_0:   result = quantize_tq1_0  (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_TQ2_0:   result = quantize_tq2_0  (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_IQ2_XXS: result = quantize_iq2_xxs(src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_IQ2_XS:  result = quantize_iq2_xs (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_IQ3_XXS: result = quantize_iq3_xxs(src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_IQ3_S:   result = quantize_iq3_s  (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_IQ2_S:   result = quantize_iq2_s  (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_IQ1_S:   result = quantize_iq1_s  (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_IQ1_M:   result = quantize_iq1_m  (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_IQ4_NL:  result = quantize_iq4_nl (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_IQ4_XS:  result = quantize_iq4_xs (src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
      case GGML_TYPE_F16:
          {
              size_t elemsize = sizeof(ggml_fp16_t);
              ggml_fp32_to_fp16_row(src + start, (ggml_fp16_t *)dst + start, n);
              result = n * elemsize;
          } break;
      case GGML_TYPE_BF16:
          {
              size_t elemsize = sizeof(ggml_bf16_t);
              ggml_fp32_to_bf16_row_ref(src + start, (ggml_bf16_t *)dst + start, n);
              result = n * elemsize;
          } break;
      case GGML_TYPE_F32:
          {
              size_t elemsize = sizeof(float);
              result = n * elemsize;
              memcpy((uint8_t *)dst + start * elemsize, src + start, result);
          } break;
      default:
          assert(false)((void) sizeof (__assert_single_arg (0)), __extension__ ({ if
 (0) ; else __assert_fail ("false", "/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7777, __extension__ __PRETTY_FUNCTION__); }));
  }

  GGML_ASSERT(result == nrows * row_size)if (!(result == nrows * row_size)) ggml_abort("/root/firefox-clang/third_party/llama.cpp/ggml/src/ggml-c.c"
, 7780, "GGML_ASSERT(%s) failed", "result == nrows * row_size"
);

  return result;
7783}

7785////////////////////////////////////////////////////////////////////////////////

7787void ggml_log_get(ggml_log_callback * log_callback, void ** user_data) {
  *log_callback = g_logger_state.log_callback;
  *user_data    = g_logger_state.log_callback_user_data;
7790}

7792void ggml_log_set(ggml_log_callback log_callback, void * user_data) {
  g_logger_state.log_callback = log_callback ? log_callback : ggml_log_callback_default;
  g_logger_state.log_callback_user_data = user_data;
7795}

7797void ggml_threadpool_params_init(struct ggml_threadpool_params * p, int n_threads) {
  p->n_threads  = n_threads;
  p->prio       = 0;     // default priority (usually means normal or inherited)
  p->poll       = 50;    // hybrid-polling enabled
  p->strict_cpu = false0; // no strict placement (all threads share same cpumask)
  p->paused     = false0; // threads are ready to go
  p->thread_create_callback = 0;
  p->thread_destroy_callback = 0;
  memset(p->cpumask, 0, GGML_MAX_N_THREADS512); // all-zero means use the default affinity (usually inherited)
7806}

7808struct ggml_threadpool_params ggml_threadpool_params_default(int n_threads) {
  struct ggml_threadpool_params p;
  ggml_threadpool_params_init(&p, n_threads);
  return p;
7812}

7814bool_Bool ggml_threadpool_params_match(const struct ggml_threadpool_params * p0, const struct ggml_threadpool_params * p1) {
  if (p0->n_threads  != p1->n_threads  ) return false0;
  if (p0->prio       != p1->prio       ) return false0;
  if (p0->poll       != p1->poll       ) return false0;
  if (p0->strict_cpu != p1->strict_cpu ) return false0;
  return memcmp(p0->cpumask, p1->cpumask, GGML_MAX_N_THREADS512) == 0;
7820}