text:
//
//  GGBTextLayer.m
//  GGB-iPhone
//
//  Created by Jens Alfke on 3/10/08.
//  Copyright 2008 __MyCompanyName__. All rights reserved.
//

#import "GGBTextLayer.h"
#import "QuartzUtils.h"

@implementation GGBTextLayer

+ (GGBTextLayer*) textLayerInSuperlayer: (CALayer*)superlayer
                               withText: (NSString*)text
                               fontSize: (float) fontSize
                              alignment: (enum CAAutoresizingMask) align
{
#if TARGET_OS_IPHONE
    UIFont *font = [UIFont systemFontOfSize: fontSize];
#else
    NSFont *font = [NSFont systemFontOfSize: fontSize];
#endif
    return [self textLayerInSuperlayer: superlayer
                              withText: text
                                  font: font
                             alignment: align];
}

+ (GGBTextLayer*) textLayerInSuperlayer: (CALayer*)superlayer
                               withText: (NSString*)text
                                   font: (id)inputFont
                              alignment: (enum CAAutoresizingMask) align
{
    GGBTextLayer *label = [[self alloc] init];
    label.string = text;

#if TARGET_OS_IPHONE
    UIFont *font = inputFont;
    [label setNeedsDisplay];
    label.needsDisplayOnBoundsChange = YES;
#else
    NSFont *font = inputFont;
    label.fontSize = font.pointSize;
#endif

    label.font = font;
    label.foregroundColor = kBlackColor;

    NSString *mode;
    if( (align & (kCALayerMinXMargin | kCALayerMaxXMargin)) == (kCALayerMinXMargin | kCALayerMaxXMargin) )
        mode = @"center";
    else {
        if( align & kCALayerWidthSizable )
            mode = @"center";
        else if( align & kCALayerMinXMargin )
            mode = @"right";
        else
            mode = @"left";
        align |= kCALayerWidthSizable;
    }
    label.alignmentMode = mode;

    // Get the bounds of the interior of the superlayer:
    CGFloat yinset = 0;
    if( [superlayer respondsToSelector: @selector(borderWidth)] )
        yinset += ((GGBLayer*)superlayer).borderWidth;
    CGFloat xinset;
    if( mode==@"center" )
        xinset = 0;
    else
        xinset = yinset + round(font.pointSize/3.0);
    CGRect bounds = CGRectInset(superlayer.bounds, xinset,yinset);

    // Compute y position of bottom of layer's frame. (Remember, descender is negative!)
    CGFloat y = bounds.origin.y;
    CGFloat descender=font.descender, height=font.ascender-descender;
    if( align & kCALayerHeightSizable ) {
        // Vertical centering:
        y += (bounds.size.height-height)/2.0;
#if ! TARGET_OS_IPHONE
        y += descender/2.0;
#endif
        align &= ~kCALayerHeightSizable;
    } else if( align & kCALayerMinYMargin ) {
        // Top alignment (Mac) or bottom (iPhone):
        y += bounds.size.height - height;
    }

    // Compute label's geometry:
    label.bounds = CGRectMake(0, descender,
                              bounds.size.width, height);
    label.anchorPoint = CGPointMake(0,0);
    label.position = CGPointMake(bounds.origin.x,y);

#if ! TARGET_OS_IPHONE
    label.autoresizingMask = align;
#endif
    [superlayer addSublayer: label];
    [label release];

#if 0 // for debugging layout, border the view
    label.borderWidth = 1;
    label.borderColor = kBlackColor;
#endif

    return label;
}

#if TARGET_OS_IPHONE
@synthesize string=_string, font=_font,
            foregroundColor=_foregroundColor, alignmentMode=_alignmentMode;

- (id) copyWithZone: (NSZone*)zone
{
    GGBTextLayer *clone = [super copyWithZone: zone];
    clone.string = _string;
    clone.font = _font;
    clone.foregroundColor = _foregroundColor;
    clone.alignmentMode = _alignmentMode;
    return clone;
}

- (void)drawInContext:(CGContextRef)ctx
{
    [super drawInContext: ctx];

    if( _string.length > 0 ) {
        CGContextSaveGState(ctx);
        UIGraphicsPushContext(ctx);

        if( _foregroundColor )
            CGContextSetFillColorWithColor(ctx, _foregroundColor);

        UITextAlignment align;
        if( [_alignmentMode isEqualToString: @"center"] )
            align = UITextAlignmentCenter;
        else if( [_alignmentMode isEqualToString: @"right"] )
            align = UITextAlignmentRight;
        else
            align = UITextAlignmentLeft;

        CGRect bounds = self.bounds;
        //float ascender=_font.ascender, descender=_font.descender, leading=_font.leading;
        //bounds.size.height -= ascender-descender - leading;

        [_string drawInRect: bounds
                   withFont: _font
              lineBreakMode: UILineBreakModeClip
                  alignment: align];

        UIGraphicsPopContext();
        CGContextRestoreGState(ctx);
    }
}

#endif

@end

/*
 .times lt mm: (TimesLTMM)
 times new roman: (TimesNewRomanBoldItalic, TimesNewRomanItalic, TimesNewRoman, TimesNewRomanBold)
 phonepadtwo: (PhonepadTwo)
 hiragino kaku gothic pron w3: (HiraKakuProN-W3)
 helvetica neue: (HelveticaNeueBold, HelveticaNeue)
 trebuchet ms: (TrebuchetMSItalic, TrebuchetMSBoldItalic, TrebuchetMSBold, TrebuchetMS)
 courier new: (CourierNewBoldItalic, CourierNewBold, CourierNewItalic, CourierNew)
 arial unicode ms: (arialuni)
 georgia: (Georgia, GeorgiaBold, GeorgiaBoldItalic, GeorgiaItalic)
 zapfino: (Zapfino)
 arial rounded mt bold: (ArialRoundedMTBold)
 db lcd temp: (DB_LCD_Temp-Black)
 verdana: (Verdana, VerdanaItalic, VerdanaBoldItalic, VerdanaBold)
 american typewriter: (AmericanTypewriterCondensedBold, AmericanTypewriter)
 helvetica: (HelveticaBoldOblique, Helvetica, HelveticaOblique, HelveticaBold)
 lock clock: (LockClock)
 courier: (CourierBoldOblique, CourierOblique)
 hiragino kaku gothic pron w6: (HiraKakuProN-W6)
 arial: (ArialItalic, ArialBold, Arial, ArialBoldItalic)
 .helvetica lt mm: (HelveticaLTMM)
 stheiti: (STHeiti, STXihei)
 applegothic: (AppleGothicRegular)
 marker felt: (MarkerFeltThin)
*/


text:
title:  Matthew 24 and 25
date:   12/05/2018
---

### Read for This Week's Study
Matt. 24:1-25, Rev. 13:11-17, Matt. 7:24-27 , Luke 21:20, Matt. 25:1-30.

>
Memory Text

> "For false messiahs and false prophets will appear and perform great signs and wonders to deceive, if possible, even the elect" (Matthew 24:24, NIV) .

In Matthew 24 and 25, Jesus reveals important truths about end times and about how to be prepared. In a sense, these chapters were Christ's teaching on last-day events. At the same time, looking to the more immediate future, He sees the impending destruction of Jerusalem, a tragedy of catastrophic proportions for His people.

But in Christ's words to His disciples, He speaks also to His followers in the generations that will follow, including and especially the last one, the one that will be alive when He does return. Jesus doesn't paint a pretty picture either. Wars, rumors of wars, pestilence, false Christs, and persecution — this will be the lot of the world, and the lot of His church. Amazingly enough, looking back through time, we can see just how accurate His predictions were. Therefore, we can trust Him for the predictions not yet fulfilled in our lifetime.

But Jesus didn't just warn about what was coming. In Matthew 25 He told parables that, if heeded, will prepare His people for when the "Son of Man" returns. Yes, hard times will come, but He will prepare a people to meet Him when He does come back.

*Study this week's lesson to prepare for Sabbath, May 19.*

redpajama_set_name: RedPajamaGithub


text:
require_relative "test_helper"

class TestRedshift < Minitest::Test
  include TestGroupdate
  include TestDatabase

  def setup
    super
    @@setup ||= begin
      abort("REDSHIFT_URL environment variable must be set in order to run tests") unless ENV["REDSHIFT_URL"].present?

      ActiveRecord::Base.establish_connection(ENV["REDSHIFT_URL"])

      create_redshift_tables
      true
    end
  end
end


text:
package dcmnet

import (
	"bytes"
	"io/ioutil"
	"reflect"
	"testing"

	"github.com/jeremyhuiskamp/dcm/dcm"
)

func TestParseAssocRQCEcho(t *testing.T) {
	exp := AssociateRQAC{
		ProtocolVersion:    1,
		CalledAE:           "RIALTO",
		CallingAE:          "DCMECHO",
		ApplicationContext: "1.2.840.10008.3.1.1.1",
		PresentationContexts: []PresentationContext{{
			ID:             PCID(1),
			Result:         PCAcceptance,
			AbstractSyntax: "1.2.840.10008.1.1",
			TransferSyntaxes: []dcm.TransferSyntax{
				dcm.ImplicitVRLittleEndian,
			},
		}},
		MaxPDULength:           16384,
		ImplementationClassUID: "1.2.40.0.13.1.1",
		ImplementationVersion:  "dcm4che-2.0",
		// hmm, not a good test, since these are the defaults:
		MaxOperationsInvoked:   0,
		MaxOperationsPerformed: 0,
	}
	got := readAssocRQAC(t, "testdata/assocrq_cecho.bin", PDUAssociateRQ)

	if !reflect.DeepEqual(exp, got) {
		t.Fatalf("expected\n%#v\ngot\n%#v", exp, got)
	}
}

func TestParseAssocACCEcho(t *testing.T) {
	exp := AssociateRQAC{
		ProtocolVersion:    1,
		CalledAE:           "RIALTO",
		CallingAE:          "DCMECHO",
		ApplicationContext: "1.2.840.10008.3.1.1.1",
		PresentationContexts: []PresentationContext{{
			ID:             1,
			Result:         PCAcceptance,
			AbstractSyntax: "",
			TransferSyntaxes: []dcm.TransferSyntax{
				dcm.ImplicitVRLittleEndian,
			},
		}},
		MaxPDULength:           16384,
		ImplementationClassUID: "1.2.40.0.13.1.1",
		ImplementationVersion:  "dcm4che-2.0",
		// hmm, not a good test, since these are the defaults:
		MaxOperationsInvoked:   0,
		MaxOperationsPerformed: 0,
	}
	got := readAssocRQAC(t, "testdata/assocac_cecho.bin", PDUAssociateAC)

	if !reflect.DeepEqual(exp, got) {
		t.Fatalf("expected\n%#v\ngot\n%#v", exp, got)
	}
}

func readAssocRQAC(t *testing.T, file string, pduType PDUType) AssociateRQAC {
	b, err := ioutil.ReadFile(file)
	if err != nil {
		t.Fatal(err)
	}

	var buf bytes.Buffer
	buf.Write(b)
	buf.WriteString("don't read me bro")

	pduDecoder := NewPDUDecoder(&buf)
	pdu, err := pduDecoder.NextPDU()
	if err != nil {
		t.Fatal(err)
	}
	if pdu == nil {
		t.Fatal("no pdu found")
	}

	if pduType != pdu.Type {
		t.Fatalf("unexpected pdu type, expected %s, got %s",
			pduType, pdu.Type)
	}
	var rqac AssociateRQAC
	rqac.Read(pdu.Data)

	if "don't read me bro" != buf.String() {
		t.Fatal("didn't stop reading at the right place")
	}

	return rqac
}


text:
using System;
using System.Collections.Generic;

namespace BusinessModel.Core.Models
{
    public partial class titleview
    {
        public string title { get; set; }
        public Nullable<byte> au_ord { get; set; }
        public string au_lname { get; set; }
        public Nullable<decimal> price { get; set; }
        public Nullable<int> ytd_sales { get; set; }
        public string pub_id { get; set; }
    }
}


text:
namespace {

// The global instance, alive for the entire lifetime of the process.
translate::RendererCldDataProviderFactory* g_instance = NULL;

// The default factory, which produces no-op instances of
// RendererCldDataProvider suitable for use when CLD data is statically-linked.
base::LazyInstance<translate::RendererCldDataProviderFactory>::Leaky
  g_wrapped_default = LAZY_INSTANCE_INITIALIZER;

}  // namespace

namespace translate {

std::unique_ptr<RendererCldDataProvider>
RendererCldDataProviderFactory::CreateRendererCldDataProvider(
    content::RenderFrameObserver* render_frame_observer) {
  return base::WrapUnique(new RendererCldDataProvider());
}

// static
bool RendererCldDataProviderFactory::IsInitialized() {
  return g_instance != nullptr;
}

// static
void RendererCldDataProviderFactory::SetDefault(
    RendererCldDataProviderFactory* instance) {
  if (!IsInitialized()) Set(instance);
}

// static
void RendererCldDataProviderFactory::Set(
    RendererCldDataProviderFactory* instance) {
    g_instance = instance;
}

// static
RendererCldDataProviderFactory* RendererCldDataProviderFactory::Get() {
  if (IsInitialized()) return g_instance;
  return &g_wrapped_default.Get();
}

}  // namespace translate


text:
package com.groupon.lex.metrics.collector.collectd;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.groupon.lex.metrics.GroupName;
import com.groupon.lex.metrics.Metric;
import com.groupon.lex.metrics.MetricGroup;
import com.groupon.lex.metrics.MetricName;
import com.groupon.lex.metrics.MetricValue;
import com.groupon.lex.metrics.SimpleGroupPath;
import com.groupon.lex.metrics.SimpleMetric;
import com.groupon.lex.metrics.SimpleMetricGroup;
import com.groupon.lex.metrics.SynchronousGroupGenerator;
import com.groupon.lex.metrics.Tags;
import com.groupon.lex.metrics.collector.collectd.grammar.CollectdTags;
import com.groupon.lex.metrics.lib.Any2;
import com.groupon.lex.metrics.lib.SimpleMapEntry;
import java.io.IOException;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import static java.util.Collections.EMPTY_MAP;
import static java.util.Collections.singleton;
import static java.util.Collections.singletonList;
import static java.util.Collections.singletonMap;
import static java.util.Collections.unmodifiableMap;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import static javax.servlet.http.HttpServletResponse.SC_OK;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NonNull;
import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
import org.joda.time.Duration;

/**
 *
 * @author ariane
 */
public class CollectdPushCollector extends SynchronousGroupGenerator {
    public static final String API_ENDPOINT_BASE = "/collectd/jsonpush/";
    public static final Duration DROP_DURATION = Duration.standardHours(1);
    private static final Type COLLECTD_TYPE = new TypeToken<List<CollectdMessage>>() {
    }.getType();
    private static final Metric UP_METRIC = new SimpleMetric(MetricName.valueOf("up"), Boolean.TRUE);
    private static final Metric DOWN_METRIC = new SimpleMetric(MetricName.valueOf("up"), Boolean.FALSE);

    private Map<String, DateTime> knownHosts = EMPTY_MAP;  // Replaced on each collection.
    private final ReadWriteLock messagesGuard = new ReentrantReadWriteLock();  // Protects messages.
    private final Map<CollectdKey, CollectdMessage> messages = new ConcurrentHashMap<>();
    @Getter
    private final SimpleGroupPath basePath;

    @EqualsAndHashCode
    public static class CollectdKey {
        public final String host, plugin, plugin_instance, type, type_instance;
        public final Map<String, Any2<String, Number>> tags;

        public CollectdKey(String host, String plugin, String plugin_instance, String type, String type_instance) {
            final Map<String, Any2<String, Number>> tags = new HashMap<>();
            this.host = host;
            this.plugin = remove_tags_(plugin, tags);
            this.plugin_instance = remove_tags_(plugin_instance, tags);
            this.type = type;
            this.type_instance = type_instance;
            this.tags = unmodifiableMap(tags);
        }

        private static String remove_tags_(String s, Map<String, Any2<String, Number>> out_tagmap) {
            final int tags_brace_open = s.indexOf('[');
            if (tags_brace_open == -1 || !s.endsWith("]"))
                return s;

            final String tag_string = s.substring(tags_brace_open + 1, s.length() - 1);
            if (!tag_string.isEmpty())
                out_tagmap.putAll(CollectdTags.parse(tag_string));

            return s.substring(0, tags_brace_open);
        }
    }

    public static class CollectdMessage {
        public List<Number> values;
        public List<String> dstypes;
        public List<String> dsnames;
        public double time;
        public long interval;
        public String host;
        public String plugin;
        public String plugin_instance;
        public String type;
        public String type_instance;

        public CollectdKey getKey() {
            return new CollectdKey(host, plugin, plugin_instance, type, type_instance);
        }

        public int metricCount() {
            return values.size();
        }

        /**
         * Work around for Google gson parser emitting numbers as 'lazily
         * parsed' numbers.
         *
         * @param elem An instance of a gson lazily parsed number.
         * @return A metric value containing the number.
         */
        private static MetricValue number_to_metric_value_(Number elem) {
            if (elem == null) return MetricValue.EMPTY;

            final String num = elem.toString();
            try {
                return MetricValue.fromIntValue(Long.parseLong(num));
            } catch (NumberFormatException ex) {
                /* SKIP */
            }
            try {
                return MetricValue.fromDblValue(Double.parseDouble(num));
            } catch (NumberFormatException ex) {
                /* SKIP */
            }
            return MetricValue.fromStrValue(num);
        }

        private MetricName to_metric_name_(String name) {
            if ("value".equals(name) && metricCount() == 1)
                name = null;

            final List<String> path = Stream.of(type, type_instance, name)
                    .filter(x -> x != null)
                    .filter(s -> !s.isEmpty())
                    .collect(Collectors.toList());
            return MetricName.valueOf(path.isEmpty() ? singletonList("value") : path);
        }

        public MetricGroup toMetricGroup(SimpleGroupPath base_path) {
            final CollectdKey key = getKey();  // Use key, as it parses the tags for us.
            final Map<String, MetricValue> tag_map = new HashMap<String, MetricValue>() {
                {
                    put("host", MetricValue.fromStrValue(host));
                    putAll(key.tags.entrySet().stream()
                            .collect(Collectors.toMap(
                                    Map.Entry::getKey,
                                    (entry -> entry.getValue().mapCombine(MetricValue::fromStrValue, MetricValue::fromNumberValue)))));
                }
            };

            final GroupName group = GroupName.valueOf(
                    SimpleGroupPath.valueOf(Stream.concat(
                            base_path.getPath().stream(),
                            Stream.of(key.plugin, key.plugin_instance)
                            .filter(x -> x != null)
                            .filter(s -> !s.isEmpty()))
                            .collect(Collectors.toList())),
                    Tags.valueOf(tag_map));

            final List<SimpleMetric> entries = new ArrayList<>(metricCount());
            for (int i = 0; i < metricCount(); ++i)
                entries.add(new SimpleMetric(to_metric_name_(dsnames.get(i)), number_to_metric_value_(values.get(i))));

            return new SimpleMetricGroup(group, entries);
        }
    }

    private class Endpoint extends HttpServlet {
        private final Gson gson = new Gson();

        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
            final List<CollectdMessage> msgs = gson.fromJson(req.getReader(), COLLECTD_TYPE);

            final Lock lck = messagesGuard.readLock();
            lck.lock();
            try {
                msgs.forEach(msg -> messages.put(msg.getKey(), msg));
            } finally {
                lck.unlock();
            }

            resp.setStatus(SC_OK);
            resp.getWriter().write("Monsoon accepted " + msgs.size() + " metric groups\n");
        }
    }

    public CollectdPushCollector(@NonNull BiConsumer<String, HttpServlet> er, @NonNull SimpleGroupPath base_path, @NonNull String name) {
        if (name.isEmpty())
            throw new IllegalArgumentException("empty endpoint name");

        er.accept(API_ENDPOINT_BASE + name, new Endpoint());
        basePath = base_path;
    }

    @Override
    public Collection<? extends MetricGroup> getGroups(CompletableFuture<TimeoutObject> timeout) {
        final DateTime now = new DateTime(DateTimeZone.UTC);
        final DateTime drop = now.minus(DROP_DURATION);

        Lock lck = messagesGuard.writeLock();
        lck.lock();
        try {
            // Transform all messages into metrics.
            final Stream<MetricGroup> msg_stream = messages.values().stream()
                    .map(cm -> cm.toMetricGroup(basePath))
                    .flatMap(mg -> Arrays.stream(mg.getMetrics()).map(m -> SimpleMapEntry.create(mg.getName(), m)))
                    .collect(Collectors.groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, Collectors.toList())))
                    .entrySet()
                    .stream()
                    .map((Map.Entry<GroupName, List<Metric>> entry) -> new SimpleMetricGroup(entry.getKey(), entry.getValue()));
            // Collect the set of hosts that are 'up'.
            final Set<String> up_hosts = messages.values().stream()
                    .map(msg -> msg.host)
                    .distinct()
                    .collect(Collectors.toSet());
            // Collect the set of hosts that are 'down'.
            final Map<String, DateTime> down_hosts = knownHosts.entrySet().stream()
                    .filter(entry -> entry.getValue().isAfter(drop)) // Don't remember host names for ever.
                    .filter(entry -> !up_hosts.contains(entry.getKey())) // No need to remember hosts that emitted metrics.
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
            // Create metrics for all up/down hosts.
            final Stream<MetricGroup> up_hosts_stream = up_hosts.stream()
                    .map(host -> up_down_host_(host, true));
            final Stream<MetricGroup> down_hosts_stream = down_hosts.keySet().stream()
                    .map(host -> up_down_host_(host, false));
            // Replace the map of known hosts.
            knownHosts = Stream.concat(down_hosts.entrySet().stream(), up_hosts.stream().map(host -> SimpleMapEntry.create(host, now)))
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

            // Done, return result.
            return Stream.of(msg_stream, up_hosts_stream, down_hosts_stream)
                    .flatMap(Function.identity())
                    .collect(Collectors.toList());
        } finally {
            messages.clear();
            lck.unlock();
        }
    }

    /**
     * Return a metric group indicating if the host is up or down.
     */
    private MetricGroup up_down_host_(String host, boolean up) {
        final GroupName group = GroupName.valueOf(
                getBasePath(),
                Tags.valueOf(singletonMap("host", MetricValue.fromStrValue(host))));
        return new SimpleMetricGroup(group, singleton(up ? UP_METRIC : DOWN_METRIC));
    }
}


text:
goog.provide('API.Client.PipelineStepImpllinks');

/**
 * @record
 */
API.Client.PipelineStepImpllinks = function() {}

/**
 * @type {!API.Client.Link}
 * @export
 */
API.Client.PipelineStepImpllinks.prototype.self;

/**
 * @type {!API.Client.Link}
 * @export
 */
API.Client.PipelineStepImpllinks.prototype.actions;

/**
 * @type {!string}
 * @export
 */
API.Client.PipelineStepImpllinks.prototype._class;


text:
from __future__ import unicode_literals

from django.conf import settings
import django.contrib.postgres.fields.jsonb
from django.db import migrations, models
import django.db.models.deletion

class Migration(migrations.Migration):

    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
        ('accounts', '0003_score'),
    ]

    operations = [
        migrations.CreateModel(
            name='TranscriptPicks',
            fields=[
                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('picks', django.contrib.postgres.fields.jsonb.JSONField()),
                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
            ],
        ),
    ]


text:
/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
/* If you are missing that file, acquire a complete release at teeworlds.com.                */
#ifndef GAME_CLIENT_COMPONENTS_CAMERA_H
#define GAME_CLIENT_COMPONENTS_CAMERA_H
#include <base/vmath.h>
#include <game/client/component.h>

class CCamera : public CComponent
{
	enum
	{
		CAMTYPE_UNDEFINED=-1,
		CAMTYPE_SPEC,
		CAMTYPE_PLAYER,
	};

	int m_CamType;
	vec2 m_PrevCenter;

public:
	vec2 m_Center;
	float m_Zoom;

	CCamera();
	virtual void OnRender();
};

#endif


text:
#ifndef CHUNK_H
#define CHUNK_H

void chunk_reset();
unsigned chunk_get();

#endif /* CHUNK_H */