text:
#ifndef CONTENT_CHILD_WEBSTATHUB_IMPL_H_
#define CONTENT_CHILD_WEBSTATHUB_IMPL_H_

#include "base/macros.h"
#include "base/trace_event/trace_event.h"
#include "content/common/content_export.h"
#include "third_party/WebKit/public/platform/WebStatHub.h"

namespace blink {
class WebData;
class WebString;
class WebURL;
class WebURLResponse;
}

template <typename T> struct DefaultSingletonTraits;

namespace content {

class CONTENT_EXPORT WebStatHubImpl : public NON_EXPORTED_BASE(blink::WebStatHub) {
 public:

  virtual ~WebStatHubImpl();

  static WebStatHubImpl* GetInstance();

  virtual blink::WebStatHubCmd cmdCreate(blink::WebStatHubCmdId cmdId);
  virtual void cmdAddParamAsString(blink::WebStatHubCmd cmd, const char* param);
  virtual void cmdAddParamAsBool(blink::WebStatHubCmd cmd, bool param);
  virtual void cmdAddParamAsUint32(blink::WebStatHubCmd cmd, unsigned int param);
  virtual void cmdAddParamAsPtr(blink::WebStatHubCmd cmd, void* param);
  virtual void cmdAddParamAsBuf(blink::WebStatHubCmd cmd, const void* param, unsigned int size);
  virtual bool cmdCommit(blink::WebStatHubCmd cmd);
  virtual bool cmdCommitDelayed(blink::WebStatHubCmd cmd, unsigned int delay);

  virtual unsigned long hash(const blink::WebURL& url);
  virtual unsigned int isPreloaded(const blink::WebURL& url);
  virtual bool getPreloaded(const blink::WebURL& url, unsigned int get_from,
      blink::WebURLResponse& response, blink::WebData& data);
  virtual bool releasePreloaded(const blink::WebURL& url);
  virtual bool isPreloaderEnabled();
  virtual bool isPerfEnabled();

  virtual bool isInspectorSpyEnabled();
  virtual bool inspectorSpyEnable();
  virtual bool inspectorSpyDisable();

 private:
  WebStatHubImpl();
  friend struct DefaultSingletonTraits<WebStatHubImpl>;

  int inspector_spy_on_;

  DISALLOW_COPY_AND_ASSIGN(WebStatHubImpl);
};

} // namespace webkit_glue

#endif //CONTENT_CHILD_WEBSTATHUB_IMPL_H_


text:
System.register([], function(exports_1, context_1) {
    "use strict";
    var __moduleName = context_1 && context_1.id;
    var BaseEvent;
    return {
        setters:[],
        execute: function() {
            BaseEvent = (function () {
                function BaseEvent(type) {
                    this.type = type;
                }
                return BaseEvent;
            }());
            exports_1("default", BaseEvent);
        }
    }
});
//# sourceMappingURL=BaseEvent.js.map

redpajama_set_name: RedPajamaGithub


text:
package io.github.mthli.Bitocle.Database.Bookmark;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

public class BHelper extends SQLiteOpenHelper {
    private static final String DATABASE_NAME = "BOOKMARK.db";
    private static final int DATABASE_VERSION = 2;

    public BHelper(Context context) {
        super(
                context,
                DATABASE_NAME,
                null,
                DATABASE_VERSION
        );
    }

    @Override
    public void onCreate(SQLiteDatabase database) {
        database.execSQL(Bookmark.CREATE_SQL);
    }

    @Override
    public void onUpgrade(SQLiteDatabase database, int oldVersion, int newVersion) {
        /* Do nothing */
    }
}


text:
function [res] = SafeShift(base, offset)
shift_max = 4294967295; % max unsigned int32
res = bitand(bitshift(base, offset), shift_max);
end


text:
package com.kalessil.phpStorm.phpInspectionsEA.inspectors.regularExpressions.classesStrategy;

import com.intellij.codeInspection.ProblemHighlightType;
import com.intellij.codeInspection.ProblemsHolder;
import com.intellij.openapi.util.text.StringUtil;
import com.jetbrains.php.lang.psi.elements.StringLiteralExpression;
import org.jetbrains.annotations.NotNull;

import java.util.HashMap;

public class ShortClassDefinitionStrategy {
    private static final String strProblemDescription = "'%p%' can be replaced with '%r%' (%h%)";

    private static HashMap<String, String> mapping = null;
    private static HashMap<String, String> getMapping() {
        if (null == mapping) {
            mapping = new HashMap<String, String>();

            mapping.put("[0-9]",         "\\d");
            mapping.put("[:digit:]",     "\\d");

            mapping.put("[^0-9]",        "\\D");
            mapping.put("[^\\d]",        "\\D");

            mapping.put("[:word:]",      "\\w");
            mapping.put("[A-Za-z0-9_]",  "\\w");
            mapping.put("[a-zA-Z0-9_]",  "\\w");

            mapping.put("[^\\w]",        "\\W");
            mapping.put("[^A-Za-z0-9_]", "\\W");
            mapping.put("[^a-zA-Z0-9_]", "\\W");

            mapping.put("[^\\s]",        "\\S");
        }

        return mapping;
    }

    static public void apply(final String modifiers, final String pattern, @NotNull final StringLiteralExpression target, @NotNull final ProblemsHolder holder) {
        if (!StringUtil.isEmpty(pattern)) {
            final boolean isUnicodeMode = !StringUtil.isEmpty(modifiers) && modifiers.indexOf('u') != -1;
            String strHint = isUnicodeMode ? "risky, will match extended sets due to /u" : "safe in non-unicode mode";

            HashMap<String, String> mapping = getMapping();
            for (String wildcard : mapping.keySet()) {
                if (pattern.contains(wildcard)) {
                    String strError = strProblemDescription
                            .replace("%p%", wildcard)
                            .replace("%r%", mapping.get(wildcard))
                            .replace("%h%", strHint);
                    holder.registerProblem(target, strError, ProblemHighlightType.WEAK_WARNING);
                }
            }

            //TODO: handle [0-9,] and similar cases when classes are part of allowed/escaped sets
        }
    }
}