text:
struct process
{
   unsigned char name[OS_NAME_LENGTH];	// process name
   int pid;								// process id
   unsigned int state;					// state of the process
   int rc;								// return code of the process

   struct rwlock *lock;					// rwlock for access to process.

   int kernel_threads;					// The number of threads inside the kernel.

   unsigned int flags;

   vmmap *map;							// virtual memory map location

   void **tls_location;					// location of process tls.

   struct thread *threads;	  		 	// Linked list of process' threads.
   struct hash_table *threads_htable;	// Hash table of process' threads.
   int thread_count;					// number of threads in process

   void* environment;					// Environment variables.
   int   environment_count;				// Environment size;

   void* lfb;

   int console;             			// Console ID used by process
   void* console_location;      		// Console location.

   time_t	usage_seconds;
   time_t	usage_milliseconds;

   struct allocated_memory *alloc; 	// Linked list of allocated memory

   struct ipc_block ipc[MAX_PORTS];	// IPC ports.
   struct shared_memory *shared;   	// Linked list of shared memory
   struct semaphore *sems;	   	// Linked list of processes' semaphores
   spinlock sems_lock;			// Semaphore lock.
   struct wait_info *waits;		// Linked list of waiting pid/tid's

   struct process *parent;
   struct process *child;
   struct process *sibling_prev;
   struct process *sibling_next;
   struct process *linear_prev;
   struct process *linear_next;

   void *data;
};

#endif


text:
using System;

namespace ZXing.Net.Mobile.Forms.iOS
{
	public static class Platform
	{
		public static void Init()
		{
			ZXing.Net.Mobile.Forms.iOS.ZXingScannerViewRenderer.Init();
			ZXing.Net.Mobile.Forms.iOS.ZXingBarcodeImageViewRenderer.Init();
		}
	}
}

redpajama_set_name: RedPajamaGithub


text:
local DEFLATE = require('compress.deflatelua')
local LZW     = require('opus.compress.lzw')
local Tar     = require('opus.compress.tar')
local Util    = require('opus.util')

local io    = _G.io
local shell = _ENV.shell

local args = { ... }

if not args[2] then
	error('Syntax: tar FILE DESTDIR')
end

local inFile = shell.resolve(args[1])
local outDir = shell.resolve(args[2])

if inFile:match('(.+)%.[gG][zZ]$') then
	-- uncompress a file created with: tar czf ...
	local fh = io.open(inFile, 'rb') or error('Error opening ' .. inFile)

	local t = { }
	local function writer(b)
		table.insert(t, b)
	end

	DEFLATE.gunzip {input=fh, output=writer, disable_crc=true}

	fh:close()

	local s, m = Tar.untar_string(string.char(table.unpack(t)), outDir, true)

	if not s then
		error(m)
	end

elseif inFile:match('(.+)%.tar%.lzw$') then
	local c = Util.readFile(inFile, 'rb')
	if not c then
		error('Unable to open ' .. inFile)
	end

	local s, m = Tar.untar_string(LZW.decompress(c), outDir, true)

	if not s then
		error(m)
	end

else
	local s, m = Tar.untar(inFile, outDir, true)
	if not s then
		error(m)
	end
end


text:
#ifndef PARSE_COLOR_H
#define PARSE_COLOR_H

#include <string>
using namespace std;

bool parse_color(int &r, int &g, int &b, const string &color);

#endif


text:
cellGrid = {}
cellWidth = 5

function love.load()
  print('hello')
  print("more info")
  initGrid(cellGrid, cellWidth)
end

function love.update()
  stepGrid(cellGrid)
end

function love.draw()
  drawGrid(cellGrid)
end

function love.quit()
  print("Closing")
end

function initGrid(grid, _cellWidth)
  grid.data = {}
  grid.wrap = true
  grid.numRows = math.floor( love.graphics.getHeight() / _cellWidth )
  grid.numCols = math.floor( love.graphics.getWidth() / _cellWidth )
  grid.numCells = grid.numRows * grid.numCols

  for i = 1,grid.numCells do
    grid.data[i] = math.random() > 0.5
  end
end

function drawGrid(grid)
  local x = 0
  local y = 0
  local row = 0
  local col = 0
  local cell

  for i = 1,grid.numCells do
    row = rowForIdx(grid, i)
    col = colForIdx(grid, i)
    cell = grid.data[i]

    if (cell) then
      love.graphics.setColor(0.2, 0.8, 0.2)
    else
      love.graphics.setColor(0.2, 0.2, 0.2)
    end

    x = col * cellWidth
    y = row * cellWidth
    love.graphics.rectangle('fill', x, y, cellWidth, cellWidth)
  end
end

function rowForIdx(grid, idx)
  return math.floor( (idx-1) / grid.numCols )
end

function colForIdx(grid, idx)
  return (idx-1) % grid.numCols
end

function stepGrid(grid)
  local newData = {}
  local tmpCount = 0

  for i = 1,grid.numCells do
    tmpCount = countSurrounding(grid, i)
    newData[i] = nextState(grid.data[i], tmpCount)
  end

  grid.data = newData
end

function neighborsForIdx(grid, idx)
  -- optimistically set them (ignoring edge cases)
  local neighbors = {}
  neighbors[1] = idx - grid.numCols - 1
  neighbors[2] = idx - grid.numCols
  neighbors[3] = idx - grid.numCols + 1
  neighbors[4] = idx - 1
  neighbors[5] = idx + 1
  neighbors[6] = idx + grid.numCols - 1
  neighbors[7] = idx + grid.numCols
  neighbors[8] = idx + grid.numCols + 1

  -- check for edge cases

  -- first row
  if (idx < grid.numCols) then
    neighbors[1] = neighbors[1] + grid.numCells
    neighbors[2] = neighbors[2] + grid.numCells
    neighbors[3] = neighbors[3] + grid.numCells
  end

  -- if in left most column
  if (idx % grid.numCols == 0) then
    neighbors[1] = neighbors[1] + grid.numCols
    neighbors[4] = neighbors[4] + grid.numCols
    neighbors[6] = neighbors[6] + grid.numCols
  end

  -- if in right most column
  if (idx % grid.numCols == (grid.numCols - 1)) then
    neighbors[3] = neighbors[3] - grid.numCols
    neighbors[5] = neighbors[5] - grid.numCols
    neighbors[8] = neighbors[8] - grid.numCols
  end

  -- if in bottom row
  if ((grid.numCells - idx) <= grid.numCols) then
    neighbors[6] = neighbors[6] - grid.numCells
    neighbors[7] = neighbors[7] - grid.numCells
    neighbors[8] = neighbors[8] - grid.numCells
  end

  return neighbors
end

function countSurrounding(grid, idx)
  local count = 0
  local neighbors = neighborsForIdx(grid, idx)
  local tmpNeighborIdx = 0

  for i=1,8 do
    tmpNeighborIdx = neighbors[i]
    if (grid.data[tmpNeighborIdx]) then
      count = count + 1
    end
  end

  return count
end

function nextState(currentState, count)
  if (currentState == true) then
    if (count < 2) then
      return false
    elseif (count > 3) then
      return false
    else
      return true
    end
  else
    return (count == 3)
  end
end


text:
package nz.net.pseudo.cb.event;

import com.google.api.services.calendar.model.Events;

/**
 * Created by i on 25/04/16.
 * Interface between main activity and asynctask
 */
public interface EventsListIface {
    void eventsAsyncTask();
    void onEventsListSuccess(Events events);
    void onFail(String title, String content);
    void autoRefreshInit();
}


text:
import React, {Component} from 'react';
import Helmet from 'react-helmet';

export default class Hello extends Component {

  render() {
    return (

Hello here

        <Helmet title="Hello"/>

    );
  }
}


text:
"""Copyright 2008 Orbitz WorldWide
   Copyright 2011 Chris Davis

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License."""

from hashlib import md5
from itertools import chain
import bisect
import sys

try:
    import mmh3
except ImportError:
    mmh3 = None

try:
    import pyhash
    hasher = pyhash.fnv1a_32()

    def fnv32a(data, seed=0x811c9dc5):
        return hasher(data, seed=seed)
except ImportError:
    def fnv32a(data, seed=0x811c9dc5):
        """
        FNV-1a Hash (http://isthe.com/chongo/tech/comp/fnv/) in Python.
        Taken from https://gist.github.com/vaiorabbit/5670985
        """
        hval = seed
        fnv_32_prime = 0x01000193
        uint32_max = 2 ** 32
        if sys.version_info >= (3, 0):
            # data is a bytes object, s is an integer
            for s in data:
                hval = hval ^ s
                hval = (hval * fnv_32_prime) % uint32_max
        else:
            # data is an str object, s is a single character
            for s in data:
                hval = hval ^ ord(s)
                hval = (hval * fnv_32_prime) % uint32_max
        return hval

def hashRequest(request):
    # Normalize the request parameters to ensure we're deterministic
    queryParams = [
        "%s=%s" % (key, '&'.join(values))
        for (key,values) in chain(request.POST.lists(), request.GET.lists())
        if not key.startswith('_')
    ]
    normalizedParams = ','.join( sorted(queryParams) )
    return compactHash(normalizedParams)

def hashData(targets, startTime, endTime, xFilesFactor):
    targetsString = ','.join(sorted(targets))
    startTimeString = startTime.strftime("%Y%m%d_%H%M")
    endTimeString = endTime.strftime("%Y%m%d_%H%M")
    myHash = targetsString + '@' + startTimeString + ':' + endTimeString + ':' + str(xFilesFactor)
    return compactHash(myHash)

def compactHash(string):
    return md5(string.encode('utf-8')).hexdigest()

def carbonHash(key, hash_type):
    if hash_type == 'fnv1a_ch':
        big_hash = int(fnv32a(key.encode('utf-8')))
        small_hash = (big_hash >> 16) ^ (big_hash & 0xffff)
    elif hash_type == 'mmh3_ch':
        if mmh3 is None:
            raise Exception('Install "mmh3" to use this hashing function.')
        small_hash = mmh3.hash(key)
    else:
        big_hash = compactHash(key)
        small_hash = int(big_hash[:4], 16)
    return small_hash

class ConsistentHashRing:
    def __init__(self, nodes, replica_count=100, hash_type='carbon_ch'):
        self.ring = []
        self.ring_len = len(self.ring)
        self.nodes = set()
        self.nodes_len = len(self.nodes)
        self.replica_count = replica_count
        self.hash_type = hash_type
        for node in nodes:
            self.add_node(node)

    def compute_ring_position(self, key):
        return carbonHash(key, self.hash_type)

    def add_node(self, key):
        self.nodes.add(key)
        self.nodes_len = len(self.nodes)
        for i in range(self.replica_count):
            if self.hash_type == 'fnv1a_ch':
                replica_key = "%d-%s" % (i, key[1])
            else:
                replica_key = "%s:%d" % (key, i)
            position = self.compute_ring_position(replica_key)
            while position in [r[0] for r in self.ring]:
                position = position + 1
            entry = (position, key)
            bisect.insort(self.ring, entry)
        self.ring_len = len(self.ring)

    def remove_node(self, key):
        self.nodes.discard(key)
        self.nodes_len = len(self.nodes)
        self.ring = [entry for entry in self.ring if entry[1] != key]
        self.ring_len = len(self.ring)

    def get_node(self, key):
        assert self.ring
        position = self.compute_ring_position(key)
        search_entry = (position, ())
        index = bisect.bisect_left(self.ring, search_entry) % self.ring_len
        entry = self.ring[index]
        return entry[1]

    def get_nodes(self, key):
        nodes = set()
        if not self.ring:
            return
        if self.nodes_len == 1:
            for node in self.nodes:
                yield node
        position = self.compute_ring_position(key)
        search_entry = (position, ())
        index = bisect.bisect_left(self.ring, search_entry) % self.ring_len
        last_index = (index - 1) % self.ring_len
        nodes_len = len(nodes)
        while nodes_len < self.nodes_len and index != last_index:
            next_entry = self.ring[index]
            (position, next_node) = next_entry
            if next_node not in nodes:
                nodes.add(next_node)
                nodes_len += 1
                yield next_node

            index = (index + 1) % self.ring_len


text:
require 'transient/activities/github'

module Transient
  module Activities
  end
end


text:
angular.module('searchInputDirective', [
])

.directive('searchInputDirective',
    function searchInputDirective($location) {
      return {
        restrict: 'E',
        replace: true,
        templateUrl: 'menus/search-input/search-input.tpl.html',
        scope: {
          placeholder: '@',
          buttonText: '@'
        },
        link: function ($scope) {
          $scope.doSearch = function(){
            if ($scope.inputModel){
              $location.path('/search').search({query: $scope.inputModel});
            }
          };
        }
      };
    });


text:
package ftrippel.utils;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;

/**
 *
 * @author https://github.com/ftrippel
 *
 */
public class FileUtils extends org.apache.commons.io.FileUtils {

	public static int head(File f, PrintStream w, int numLines) {
		BufferedReader br = null;
		String line = null;
		int i = 0;
		try {
			br = new BufferedReader(new FileReader(f));
			while (i < numLines && (line = br.readLine()) != null) {
				w.println(line);
				++i;
			}
			br.close();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		return i;
	}

	public static boolean fileEquals(File in1, File in2) throws IOException {
		return streamEquals(new BufferedInputStream(new FileInputStream(in1)), new BufferedInputStream(new FileInputStream(in2)));
	}

	public static boolean streamEquals(InputStream in1, InputStream in2) throws IOException {
		boolean ok = true;
		int b = 0;
		while ((ok = ((b = in1.read()) == in2.read()))) {
			if (b < 0)
				break;
		}
		in1.close();
		in2.close();
		return ok;
	}

}


text:
local addon,ns = ...

local gUI4 = GP_LibStub("GP_AceAddon-3.0"):GetAddon("gUI4", true)
if not gUI4 then return end

local oUF = gUI4.oUF
if not oUF then return end

local parent = gUI4:GetModule("gUI4_UnitFrames")
if not parent then return end

local module = parent:NewModule("ToTTarget", "GP_AceEvent-3.0")
local L = GP_LibStub("GP_AceLocale-3.0"):GetLocale("gUI4")
local LMP = GP_LibStub("GP_LibMediaPlus-1.0")

-- Lua API
local unpack = unpack

local defaults = {
	profile = {
		locked = true,
		position = {
			-- point = "BOTTOM",
			-- x = -(110 + 276/2),
			-- y = 51
		}
	}
}

local function scaffolding(self, unit)
	-- statusbars
	self.Health = LMP:NewChain("StatusBar", nil, self) :SetFrameLevel(self:GetFrameLevel() + 1) :SetPostUpdate(ns.postUpdateHealth) .__EndChain
	self.Health.OverlayFrame = LMP:NewChain(CreateFrame("Frame", nil, self.OverlayFrame)) :SetAllPoints() .__EndChain
	self.Health.Glow = LMP:NewChain(self.Health.OverlayFrame:CreateTexture()) :SetDrawLayer("BACKGROUND", -7) :SetAllPoints() :SetVertexColor(0, 0, 0, 1) .__EndChain
	self.Health.Border = LMP:NewChain(self.Health.OverlayFrame:CreateTexture()) :SetDrawLayer("ARTWORK", 1) .__EndChain
	self.Health.Highlight = LMP:NewChain(self.Health.OverlayFrame:CreateTexture()) :Hide() :SetDrawLayer("ARTWORK", 2) .__EndChain
	self.Health.Overlay = LMP:NewChain(self.Health.OverlayFrame:CreateTexture()) :Hide() :SetDrawLayer("ARTWORK", 3) .__EndChain

	-- move this to profile or theme or both?
	self.Health.colorHealth = true
	self.Health.colorClass = true
	self.Health.colorClassPet = false
	self.Health.colorPetAsPlayer = false -- let's keep this one to the player pet frame only
	self.Health.colorReaction = true
	self.Health.colorDisconnected = true
	self.Health.colorTapping = true
	self.Health.colorSmooth = true

	self.Health.Smoother = true
	self.Health.frequentUpdates = true
	-- self.Health.SpiritHealer = self.SpiritHealer -- connect the spirithealer artwork
	self.Health.Override = gUI4:GetFunction("UpdateHealthBar")

	-- low health pulse
	local build = tonumber((select(2, GetBuildInfo())))
	if build >= 22124 then -- Legion
		self.Health.Pulse = LMP:NewChain(self.Health:CreateTexture()) :Hide() :SetDrawLayer("BORDER", 1) :SetAllPoints(self.Health:GetStatusBarTexture()) :SetBlendMode("BLEND") :SetColorTexture(1,0,0,.5) .__EndChain
		self.Health.Pulse.Anim = LMP:NewChain(self.Health.Pulse:CreateAnimationGroup()) :SetLooping("REPEAT") .__EndChain
		self.Health.Pulse.Anim.start = LMP:NewChain(self.Health.Pulse.Anim:CreateAnimation("Alpha")) :SetToAlpha(0) :SetDuration(0) :SetSmoothing("IN") :SetOrder(0) .__EndChain
		self.Health.Pulse.Anim.fadeIn = LMP:NewChain(self.Health.Pulse.Anim:CreateAnimation("Alpha")) :SetToAlpha(.5) :SetDuration(.5) :SetOrder(1) .__EndChain
		self.Health.Pulse.Anim.fadeOut = LMP:NewChain(self.Health.Pulse.Anim:CreateAnimation("Alpha")) :SetToAlpha(0) :SetDuration(.5) :SetOrder(2) .__EndChain
		self.Health.Pulse.Anim:Play()
	else
		self.Health.Pulse = LMP:NewChain(self.Health:CreateTexture()) :Hide() :SetDrawLayer("BORDER", 1) :SetAllPoints(self.Health:GetStatusBarTexture()) :SetBlendMode("BLEND") :SetTexture(1,0,0,.5) .__EndChain
		self.Health.Pulse.Anim = LMP:NewChain(self.Health.Pulse:CreateAnimationGroup()) :SetLooping("REPEAT") .__EndChain
		self.Health.Pulse.Anim.start = LMP:NewChain(self.Health.Pulse.Anim:CreateAnimation("Alpha")) :SetChange(-1) :SetDuration(0) :SetSmoothing("IN") :SetOrder(0) .__EndChain
		self.Health.Pulse.Anim.fadeIn = LMP:NewChain(self.Health.Pulse.Anim:CreateAnimation("Alpha")) :SetChange(.5) :SetDuration(.5) :SetOrder(1) .__EndChain
		self.Health.Pulse.Anim.fadeOut = LMP:NewChain(self.Health.Pulse.Anim:CreateAnimation("Alpha")) :SetChange(-.5) :SetDuration(.5) :SetOrder(2) .__EndChain
		self.Health.Pulse.Anim:Play()
	end

	-- health spark
	self.Health.Spark = LMP:NewChain(self.Health:CreateTexture()) :SetDrawLayer("BORDER", 2) .__EndChain

	-- castbar
	self.Castbar = LMP:NewChain("StatusBar", nil, self) :SetFrameLevel(self:GetFrameLevel() + 3) .__EndChain
	self.Castbar.OverlayFrame = LMP:NewChain(CreateFrame("Frame", nil, self.OverlayFrame)) .__EndChain
	self.Castbar.BackdropFrame = LMP:NewChain(CreateFrame("Frame", nil, self)) :SetAllPoints(self.Castbar.OverlayFrame) .__EndChain
	self.Castbar.Glow = LMP:NewChain(self.Castbar.OverlayFrame:CreateTexture()) :SetDrawLayer("BACKGROUND", -7) :SetAllPoints() :SetVertexColor(0, 0, 0, 1) .__EndChain
	self.Castbar.Border = LMP:NewChain(self.Castbar.OverlayFrame:CreateTexture()) :SetDrawLayer("ARTWORK", 1) .__EndChain
	self.Castbar.Highlight = LMP:NewChain(self.Castbar.OverlayFrame:CreateTexture()) :Hide() :SetDrawLayer("ARTWORK", 2) .__EndChain
	self.Castbar.Overlay = LMP:NewChain(self.Castbar.OverlayFrame:CreateTexture()) :Hide() :SetDrawLayer("ARTWORK", 3) .__EndChain
	-- self.Castbar.SafeZone = LMP:NewChain(self.Castbar:CreateTexture()) :SetDrawLayer("OVERLAY") :SetAllPoints(self.Castbar) :SetAlpha(1/4) .__EndChain
	self.Castbar.Icon = LMP:NewChain(self.Castbar.OverlayFrame:CreateTexture()) :SetDrawLayer("BACKGROUND", 0) :SetTexCoord(5/64, 59/64, 5/64, 59/64) .__EndChain
	self.Castbar.Icon.Glow = LMP:NewChain(self.Castbar.OverlayFrame:CreateTexture()) :SetDrawLayer("BACKGROUND", -7) :SetAllPoints() :SetVertexColor(0, 0, 0, 1) .__EndChain
	self.Castbar.Icon.Border = LMP:NewChain(self.Castbar.OverlayFrame:CreateTexture()) :SetDrawLayer("ARTWORK", 1) .__EndChain
	self.Castbar.Icon.Overlay = LMP:NewChain(self.Castbar.OverlayFrame:CreateTexture()) :Hide() :SetDrawLayer("ARTWORK", 3) .__EndChain
	self.Castbar.Time = LMP:NewChain("FontString", nil, self.InfoFrame) :SetDrawLayer("OVERLAY") :SetFontObject(TextStatusBarText) .__EndChain
	self.Castbar.CustomTimeText = function(self, duration)
		if self.casting then
			self.Time:SetFormattedText("%.1f", self.max - duration)
		elseif self.channeling then
			self.Time:SetFormattedText("%.1f", duration)
		end
	end

	-- portrait
	self.Portrait = LMP:NewChain(CreateFrame("PlayerModel", nil, self)) :SetAlpha(1) .__EndChain
	self.Portrait.PostUpdate = gUI4:GetFunction("PostUpdatePortrait")
	self.Portrait.OverlayFrame = LMP:NewChain(CreateFrame("Frame", nil, self.OverlayFrame)) :SetAllPoints(self.Portrait) .__EndChain
	tinsert(self.__elements, gUI4:GetFunction("HidePortrait"))

	-- threat
	self.Health.Threat = LMP:NewChain(self.Health.OverlayFrame:CreateTexture()) :SetDrawLayer("ARTWORK", 4) :SetAllPoints() :Hide() .__EndChain
	self.Threat = {
		Hide = function()
			self.Health.Threat:Hide()
		end,
		Show = function()
			if self.Health.Threat.enabled then
				self.Health.Threat:Show()
			end
		end,
		SetVertexColor = function(frame, ...)
			self.Health.Threat:SetVertexColor(...)
		end,
		IsObjectType = function()
		end
	}

  -- fontstrings
	self.CombatFeedbackText = LMP:NewChain("FontString", nil, self.InfoFrame) :SetDrawLayer("ARTWORK") :SetFontObject(NumberFontNormalHuge) .__EndChain
	self.HealthText = LMP:NewChain("FontString", nil, self.InfoFrame) :SetDrawLayer("ARTWORK") :SetFontObject(TextStatusBarText) .__EndChain
	self.NameText = LMP:NewChain("FontString", nil, self.InfoFrame) :SetDrawLayer("ARTWORK") :SetFontObject(GameFontNormalSmall) :SetWordWrap(false) :SetNonSpaceWrap(false) .__EndChain

	-- widgets
	self.RaidIcon = LMP:NewChain(self.IconFrame:CreateTexture()) :SetDrawLayer("OVERLAY") .__EndChain
	self.UnitRange = { insideAlpha = 1, outsideAlpha = .75 }
	self.HealPrediction = {
		myBar = LMP:NewChain("StatusBar", nil, self) :SetStatusBarTexture(1, 1, 1, .3) :SetStatusBarColor(unpack(self.colors.healpredict.predict)) .__EndChain,
		otherBar = LMP:NewChain("StatusBar", nil, self) :SetStatusBarTexture(1, 1, 1, .3) :SetStatusBarColor(unpack(self.colors.healpredict.predictOther)) .__EndChain,
		absorbBar = LMP:NewChain("StatusBar", nil, self) :SetStatusBarTexture(1, 1, 1, .3) :SetStatusBarColor(unpack(self.colors.healpredict.absorb)) .__EndChain,
		healAbsorbBar = LMP:NewChain("StatusBar", nil, self) :SetStatusBarTexture(1, 1, 1, .3) :SetStatusBarColor(unpack(self.colors.healpredict.absorbOther)) .__EndChain,
		maxOverflow = 1,
		frequentUpdates = true
	}

	-- frame references
	self.CastbarText = self.Castbar.Time
	self.CastbarText.frame = self
	self.CombatFeedbackText.frame = self
	self.Health.frame = self
	self.HealthText.frame = self
	self.NameText.frame = self

end

function module:ApplySettings()
end
module.ApplySettings = gUI4:SafeCallWrapper(module.ApplySettings)

function module:OnInitialize()
	self.db = parent.db:RegisterNamespace("ToTTarget", defaults)
	self.db.RegisterCallback(self, "OnProfileChanged", "ApplySettings")
	self.db.RegisterCallback(self, "OnProfileCopied", "ApplySettings")
	self.db.RegisterCallback(self, "OnProfileReset", "ApplySettings")
end

function module:OnEnable()
	self:AddUnit("targettargettarget", scaffolding, self.db.profile)
end


text:
using System.Configuration;

namespace egodb
{
    public abstract class BaseIdentity<T>
    {
        protected BaseIdentity()
        {
           DocumentMetaData=new DocumentMetaData();
        }

        public abstract T Id {  set; get; }
        public  long Number
        {
             set;
            get;
        }

        public  DocumentMetaData DocumentMetaData
        {
          set; get;
        }
    }
    public class BaseIdentity:BaseIdentity<string>
    {

        public override string Id {
             set;
            get;
        }
    }
}