text:
Die Thomaskirche ist neben der Magdalenenkirche und der Martinskirche eine von drei evangelischen Kirchen in der süddeutschen Stadt Pfullingen. Alle drei Kirchen gehören zur Evangelischen Kirchengemeinde Pfullingen.

Die Thomaskirche (nach dem Apostel Thomas) wurde nach einem Entwurf des Stuttgarter Architekturbüros Kenèz und Jäger erbaut und am 13. Oktober 1991 eingeweiht. Sie liegt unterhalb des Wohngebiets Ahlsberg im Süden Pfullingens und dient als Ersatz für die als Provisorium erbaute Pauluskirche, die am 6. Juni 2004 geschlossen und mittlerweile abgerissen wurde.

Gemeinde

Die Thomaskirche gehört zum Pfarramt Süd der Evangelischen Kirchengemeinde Pfullingen, die der Evangelischen Landeskirche in Württemberg angehört. Die zuständige Pfarrerin für das Gemeindezentrum ist seit September 2018 Ulrike Kuhlmann, die zuvor in der Martinskirche tätig war. Vor ihr wurde die Gemeinde zunächst von Michael Hägele, ab August 1993 Martin Tuttaß betreut. Dem Gemeindezentrum gehören rund 2000 Gemeindeglieder an (Stand: 2016).

2017 schlossen sich die drei evangelischen Kirchengemeinden Pfullingens, die Magdalenenkirchengemeinde, die Martinskirchengemeinde und die Thomaskirchengemeinde, zu einer Gesamtkirchengemeinde, der Evangelischen Kirchengemeinde Pfullingen, mit einem gemeinsamen Kirchengemeinderat zusammen. Die bisherigen Gemeinden bilden nun Gemeindezentren, wobei das Gemeindezentrum Martinskirche nach wie vor in die zwei Pfarrbezirke Ost und West mit je einem eigenen Pfarrer untergliedert ist.

Siehe auch

 Kirchenbezirk Reutlingen#Kirchengemeinde Pfullingen
 Pfullingen#Religion

Weblinks
Webpräsenz des Gemeindezentrums Thomaskirche

Einzelnachweise

Pfullingen
Kirchengebäude in Pfullingen
Pfullingen Thomaskirche
Erbaut in den 1990er Jahren
Pfullingen
Pfullingen


text:
Q: Is there any way to run a Foreground service continuously in .NET MAUI (Android )? I have a foreground service which gets the device's location every 5 seconds and sends it to a server. But every day or so, the location data will not get uploaded to the server even though the foreground service is still running. I'm running the get location service on a different thread.
Foreground Service StartCommandResult Method
public override StartCommandResult OnStartCommand(Intent intent, [GeneratedEnum] StartCommandFlags flags, int startId)
{
    switch (intent.Action)
    {
        case "START_SERVICE":
            Console.WriteLine("Start Service");
            Task.Run(() =>
            {
                Console.WriteLine("Task is running");
                try
                {
                    var locShare = new GetLocationService();
                    locShare.RunLocation(_cts.Token).Wait();
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                    throw;
                }
            }, _cts.Token);

            RegisterNotification(); //Proceed to notify
            break;

        case "STOP_SERVICE":
            _cts.Cancel();
            StopForeground(true);
            StopSelfResult(startId);
            _cts.Dispose();
            break;
    }

Get Location Service Class
public async Task RunLocation(CancellationToken token)
{
    await Task.Run(async () =>
    {
        if (token.IsCancellationRequested)
            stopping = true;
        while (!stopping)
        {
            token.ThrowIfCancellationRequested();
            try
            {
                await Task.Delay(5000, token);

                var request = new GeolocationRequest(GeolocationAccuracy.Medium, TimeSpan.FromSeconds(5));
                var location = await Geolocation.Default.GetLocationAsync(request, token);

                if (location != null)
                {
                    var gpsData = new GpsRecord()
                    {
                        Id = Guid.NewGuid(),
                        DateTime = location.Timestamp.DateTime,
                        GPSData = location.ToString(),
                        IsSync = 1,

                    };

                    gpsRecordList.Add(gpsData);

                    if (InternetService.Internet)
                    {
                        try
                        {
                            var result = await data.PostRecordAsync(gpsRecordList);
                            Debug.WriteLine("result: " + result.StatusCode + " " + DateTime.Now.ToString("O"));
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e);
                        }

                        if (_isOfflineSync)
                        {
                            try
                            {
                                var syncOfflineData = new SyncOfflineData();
                                await syncOfflineData.Start();
                                _isOfflineSync = false;
                            }
                            catch (Exception e)
                            {
                                Debug.WriteLine(e);
                            }
                        }
                    }
                    else
                    {
                        _isOfflineSync = true;
                        try
                        {
                            gpsData.IsSync = 0;
                            var result = await DatabaseConnectionService.AddRecordAsync(gpsData);
                            Debug.WriteLine(result);
                            Debug.WriteLine("Added to local database");
                        }
                        catch (Exception e)
                        {
                            Debug.WriteLine(e);
                            throw;
                        }
                    }

                    gpsRecordList.Clear();
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex);
            }
        }
        return;
    }, token);
}

redpajama_set_name: RedPajamaStackExchange


The Ohio Lakefront Group has been working to ensure that all members of OLG class action lawsuit receive as much money as possible from the settlement. There is a provision in the Settlement that calls for the Administrator to distribute unclaimed funds to Class Members that originally filed a claim.
There were unclaimed funds, so a second distribution is in order. To qualify for the second distribution you had to have previously put in a claim for damages (not about leases), and you had to have cashed the check. If the check you got was $100 or less, you will not be getting a second check. In order to save administrative costs, the Court Stipulation provided that the Administrator did not have to send out check for $20.00 or less.
If you qualified for the second distribution, you should have received a check by now for approximately 20% of the first check you received.
The generous support of OLG by our Members has allowed us to advocate on your behalf for not only the first compensation check you received, but also for this second check as well. As long as OLG is financially viable, we hope to keep fighting for your property rights and against inappropriate governmental behavior.


Discover Barbie Fairytale Magic with the Barbie Glitter Princess Nikki Fairytale Magic Doll! Barbie princesses are classic with a modern twist and ready for any adventure. This Barbie princess is dressed in a full-length gown with a detailed glittery bodice. Her gorgeous removable skirt, featuring a shiny pink print, can be mixed and matched with any OPP Fairy or OPP Mermaid doll. An enhanced tiara and elegant shoes add girly regal touches. Includes doll with removable skirt, tiara and shoes. Doll cannot stand alone.


text:
RAJAR Q4/2021
What is the radio audience up to? (6 minute read)
The second RAJAR since the COVID hiatus has appeared and after the excitement of last quarter's new stations and changes in behaviour, this wave is a little more muted.
As I talked about last time, youth radio is finding it difficult to control declines, many of which seem structural rather than cyclical. Radio 1 has had its worst ever quarter for both 10+ and 15+. The station is very much in build mode, with much of this quarter bearing the brunt of new mid-morning, drive and evening shows. Faced with all of that, a small dip from 8.2m to 8.1m is probably not that bad.
Over at Capital, Breakfast with Roman Kemp is having share problems. Generally breakfast audience share exceeds the station's average. If you put loads of effort into a breakfast show you would assume it will outperform the more functional aspects of a station. Over at Radio 1, Greg James gets a 6.1% share compared to the station average of 5.4%, Kiss' new-ish breakfast show has a 1% share nationally, the same average as the station, and in London breakfast is on 2.6% vs the station's 2.4%.
For Roman and the team, their show is 2.9% in London (vs 3.2% for the station) and nationally is 2.6% (vs 2.9% for the station). Capital has suffered for a long time with low average hours - which will impact share. It's also kept its breakfast show at the regular 6 to 10am time, whilst Radio 1's moved Greg from 7 to 10.30am, and Kiss Breakfast with Jordan and Perri is 7 to 11am, perhaps not maximising the available audience.
Indeed, down the corridor at Radio X, Chris Moyles is delivering a 3.2% share in London and a 2.9% share nationwide - better than Capital. Radio X has a third of the reach of Capital, but Moyles is delivering more listening hours. I thought I'd also check out the average ages, for Roman's show its 36.7 and Moyles is 38.3 - not actually that different.
Commercial radio ads are sold based on the amount of impacts - this is directly related to the volume of listening hours a station generates - more impacts, more revenue. Now, clearly, demographics do come into play and certain audiences are worth more than others - but youth radio stations' low average hours, often with declining reaches, means total hours are likely to decline even faster.
In the last ten years, Capital's lost a third of its hours nationwide and half of its hours in London. In the last five years Kiss has halved its hours. Plus Capital Xtra's sitting on its worst hours for a long time. Clearly, some of this comes from increased competition, but declining total youth hours doesn't help either.
I think there is a danger that the declining audiences means its much harder for groups to make money from youth radio. If that results in cutting investment, then you potentially get stuck in a loop of declining revenue and audience that you can't get out of. Any lack of provision for young audiences puts at risk bringing new listeners into the medium. And that's bad news for radio stations targeting older listeners later on.
Greatest Hits Radio
In London, Bauer's Greatest Hits Radio took over Absolute's 105.8FM frequency in May last year. Both stations have been on digital platforms throughout, though the FM change happened in the middle of the chart below, just before Q3, 2021.
Absolute has not unexpectedly seen a decline, but this has been more than made up by GHR's appearance. GHR has also been attracting a different audience to Absolute. So whilst Absolute has declined its audience have found it on other platforms, whilst a new audience has come to GHR, discovering it through FM. The bottom line shows a combo of audiences, demonstrating the increase in reach and hours for Bauer overall.
The Simon Mayo affect has probably propelled GHR in London and also in Liverpool (where it had been on FM for a while). This has helped it grow its audience across the UK to 3.08m (from 2.89m). These increases though do hide a more mixed bag from many of the stations that were acquired and re-branded. Some that had strong heritage have had precipitous drops. The Eagle in Surrey has fallen from 107k two years ago to just 40k now.
Local and Networks
Rebranding into networks however, for many stations, is probably the best chance of those frequencies remaining viable.
I counted 57 commercial FM stations that are still locally branded - the Pirate FM's and Radio Pembrokeshire's of the world. Reach-wise 49 of them were down quarter on quarter. Over at the BBC it's a similar story, with just 13 of their stations increasing reach. The hours story for both is not dissimilar.
To pick one example, Free Radio Birmingham, or BRMB in old money, currently has a reach of just 115k. To compare, it was over 500k in 2004 and even over 300k in 2016.
The choice provided by digital radio makes it increasingly tough for heritage stations with a broad pop music radio format to succeed.
This isn't helped by only 36% of radio's listening hours now being from AM/FM. DAB on its own is 43.2%. All the digital hours combined are 64%. Analogue reach is only 64.7% now, compared to digital's reach of 80.3%. UK radio listening now is very much a digital endeavour. The sheer volume of national competition means it's harder and harder each quarter for local stations to compete.
A lot of this post has been around declines, but there's some good news too. Planet Rock, one of the first national digital radio stations, has had its best reach ever at 1.4m (it's also the biggest digital-only commercial station for hours - 10.6m of them). It just shows that audience growth can happen for any station.
New kids on the block, Boom Radio had a small reach bump (from 233k to 242k) but delivered strong hours growth, driven by high average hours. They're now doing 2.4m hours (up from 1.8m hours last quarter). It's an hours performance that makes them bigger than the BBC Asian Network, Heart 90s, Jazz FM and many more. If they keep their average hours up and grow their reach then they'll end up doing very well.
Over at Fun Kids we've had our best ever RAJAR. We measure in London and look at the 10 plus data, even though that's outside our target demo (but sadly RAJAR doesn't go any lower). We've got 122k 10+ listeners in London, which is more than talkRADIO, Hits Radio, Heart 90s, Capital Dance and 30 other stations. Not that I'm counting.
Adam Bowie does excellent RAJAR round-ups and you can find his here.
He'll also be joining me on the Media Podcast this week to talk RAJAR. It'll be out tomorrow, so subscribe in your podcast app of choice!
If you just read my RAJAR posts shame on you! I write about radio, podcasts and streaming each week and you can receive it free in your inbox by signing up here.

redpajama_set_name: RedPajamaCommonCrawl


It delivers style and power in a single package! A turbocharger is also included as an economical means of increasing performance. Top features include leather upholstery, heated and ventilated seats, adjustable pedals, and power seats. Smooth gearshifts are achieved thanks to the 3.5 liter 6 cylinder engine, and for added security, dynamic Stability Control supplements the drivetrain.


text:
using NMF.Collections.Generic;
using NMF.Collections.ObjectModel;
using NMF.Expressions;
using NMF.Expressions.Linq;
using NMF.Models;
using NMF.Models.Collections;
using NMF.Models.Expressions;
using NMF.Models.Meta;
using NMF.Models.Repository;
using NMF.Serialization;
using NMF.Utilities;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;

namespace NMF.Interop.Ecore
{

    /// <summary>
    /// The default implementation of the EClassifier class
    /// </summary>
    [XmlNamespaceAttribute("http://www.eclipse.org/emf/2002/Ecore")]
    [XmlNamespacePrefixAttribute("ecore")]
    [ModelRepresentationClassAttribute("http://www.eclipse.org/emf/2002/Ecore#//EClassifier/")]
    [DebuggerDisplayAttribute("EClassifier {Name}")]
    public abstract class EClassifier : ENamedElement, IEClassifier, IModelElement
    {

        /// <summary>
        /// The backing field for the InstanceClassName property
        /// </summary>
        private string _instanceClassName;

        /// <summary>
        /// The backing field for the InstanceTypeName property
        /// </summary>
        private string _instanceTypeName;

        /// <summary>
        /// The backing field for the ETypeParameters property
        /// </summary>
        private ObservableCompositionOrderedSet<IETypeParameter> _eTypeParameters;

        private static IClass _classInstance;

        public EClassifier()
        {
            this._eTypeParameters = new ObservableCompositionOrderedSet<IETypeParameter>(this);
            this._eTypeParameters.CollectionChanging += this.ETypeParametersCollectionChanging;
            this._eTypeParameters.CollectionChanged += this.ETypeParametersCollectionChanged;
        }

        /// <summary>
        /// The instanceClassName property
        /// </summary>
        [XmlElementNameAttribute("instanceClassName")]
        [XmlAttributeAttribute(true)]
        public virtual string InstanceClassName
        {
            get
            {
                return this._instanceClassName;
            }
            set
            {
                if ((this._instanceClassName != value))
                {
                    string old = this._instanceClassName;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnInstanceClassNameChanging(e);
                    this.OnPropertyChanging("InstanceClassName", e);
                    this._instanceClassName = value;
                    this.OnInstanceClassNameChanged(e);
                    this.OnPropertyChanged("InstanceClassName", e);
                }
            }
        }

        /// <summary>
        /// The instanceTypeName property
        /// </summary>
        [XmlElementNameAttribute("instanceTypeName")]
        [XmlAttributeAttribute(true)]
        public virtual string InstanceTypeName
        {
            get
            {
                return this._instanceTypeName;
            }
            set
            {
                if ((this._instanceTypeName != value))
                {
                    string old = this._instanceTypeName;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnInstanceTypeNameChanging(e);
                    this.OnPropertyChanging("InstanceTypeName", e);
                    this._instanceTypeName = value;
                    this.OnInstanceTypeNameChanged(e);
                    this.OnPropertyChanged("InstanceTypeName", e);
                }
            }
        }

        /// <summary>
        /// The ePackage property
        /// </summary>
        [XmlElementNameAttribute("ePackage")]
        [DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden)]
        [XmlAttributeAttribute(true)]
        [XmlOppositeAttribute("eClassifiers")]
        public virtual IEPackage EPackage
        {
            get
            {
                return ModelHelper.CastAs<IEPackage>(this.Parent);
            }
            set
            {
                this.Parent = value;
            }
        }

        /// <summary>
        /// The eTypeParameters property
        /// </summary>
        [DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content)]
        [XmlElementNameAttribute("eTypeParameters")]
        [XmlAttributeAttribute(false)]
        [ContainmentAttribute()]
        [ConstantAttribute()]
        public virtual IOrderedSetExpression<IETypeParameter> ETypeParameters
        {
            get
            {
                return this._eTypeParameters;
            }
        }

        /// <summary>
        /// Gets the child model elements of this model element
        /// </summary>
        public override IEnumerableExpression<IModelElement> Children
        {
            get
            {
                return base.Children.Concat(new EClassifierChildrenCollection(this));
            }
        }

        /// <summary>
        /// Gets the referenced model elements of this model element
        /// </summary>
        public override IEnumerableExpression<IModelElement> ReferencedElements
        {
            get
            {
                return base.ReferencedElements.Concat(new EClassifierReferencedElementsCollection(this));
            }
        }

        /// <summary>
        /// Gets the Class model for this type
        /// </summary>
        public new static IClass ClassInstance
        {
            get
            {
                if ((_classInstance == null))
                {
                    _classInstance = ((IClass)(MetaRepository.Instance.Resolve("http://www.eclipse.org/emf/2002/Ecore#//EClassifier/")));
                }
                return _classInstance;
            }
        }

        /// <summary>
        /// Gets fired before the InstanceClassName property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> InstanceClassNameChanging;

        /// <summary>
        /// Gets fired when the InstanceClassName property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> InstanceClassNameChanged;

        /// <summary>
        /// Gets fired before the InstanceTypeName property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> InstanceTypeNameChanging;

        /// <summary>
        /// Gets fired when the InstanceTypeName property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> InstanceTypeNameChanged;

        /// <summary>
        /// Gets fired before the EPackage property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> EPackageChanging;

        /// <summary>
        /// Gets fired when the EPackage property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> EPackageChanged;

        /// <summary>
        /// Raises the InstanceClassNameChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnInstanceClassNameChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.InstanceClassNameChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Raises the InstanceClassNameChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnInstanceClassNameChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.InstanceClassNameChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Raises the InstanceTypeNameChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnInstanceTypeNameChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.InstanceTypeNameChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Raises the InstanceTypeNameChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnInstanceTypeNameChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.InstanceTypeNameChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Raises the EPackageChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnEPackageChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.EPackageChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Gets called when the parent model element of the current model element is about to change
        /// </summary>
        /// <param name="oldParent">The old parent model element</param>
        /// <param name="newParent">The new parent model element</param>
        protected override void OnParentChanging(IModelElement newParent, IModelElement oldParent)
        {
            IEPackage oldEPackage = ModelHelper.CastAs<IEPackage>(oldParent);
            IEPackage newEPackage = ModelHelper.CastAs<IEPackage>(newParent);
            ValueChangedEventArgs e = new ValueChangedEventArgs(oldEPackage, newEPackage);
            this.OnEPackageChanging(e);
            this.OnPropertyChanging("EPackage");
        }

        /// <summary>
        /// Raises the EPackageChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnEPackageChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.EPackageChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Gets called when the parent model element of the current model element changes
        /// </summary>
        /// <param name="oldParent">The old parent model element</param>
        /// <param name="newParent">The new parent model element</param>
        protected override void OnParentChanged(IModelElement newParent, IModelElement oldParent)
        {
            IEPackage oldEPackage = ModelHelper.CastAs<IEPackage>(oldParent);
            IEPackage newEPackage = ModelHelper.CastAs<IEPackage>(newParent);
            if ((oldEPackage != null))
            {
                oldEPackage.EClassifiers.Remove(this);
            }
            if ((newEPackage != null))
            {
                newEPackage.EClassifiers.Add(this);
            }
            ValueChangedEventArgs e = new ValueChangedEventArgs(oldEPackage, newEPackage);
            this.OnEPackageChanged(e);
            this.OnPropertyChanged("EPackage", e);
            base.OnParentChanged(newParent, oldParent);
        }

        /// <summary>
        /// Forwards CollectionChanging notifications for the ETypeParameters property to the parent model element
        /// </summary>
        /// <param name="sender">The collection that raised the change</param>
        /// <param name="e">The original event data</param>
        private void ETypeParametersCollectionChanging(object sender, NMF.Collections.ObjectModel.NotifyCollectionChangingEventArgs e)
        {
            this.OnCollectionChanging("ETypeParameters", e);
        }

        /// <summary>
        /// Forwards CollectionChanged notifications for the ETypeParameters property to the parent model element
        /// </summary>
        /// <param name="sender">The collection that raised the change</param>
        /// <param name="e">The original event data</param>
        private void ETypeParametersCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            this.OnCollectionChanged("ETypeParameters", e);
        }

        /// <summary>
        /// Gets the relative URI fragment for the given child model element
        /// </summary>
        /// <returns>A fragment of the relative URI</returns>
        /// <param name="element">The element that should be looked for</param>
        protected override string GetRelativePathForNonIdentifiedChild(IModelElement element)
        {
            int eTypeParametersIndex = ModelHelper.IndexOfReference(this.ETypeParameters, element);
            if ((eTypeParametersIndex != -1))
            {
                return ModelHelper.CreatePath("eTypeParameters", eTypeParametersIndex);
            }
            return base.GetRelativePathForNonIdentifiedChild(element);
        }

        /// <summary>
        /// Resolves the given URI to a child model element
        /// </summary>
        /// <returns>The model element or null if it could not be found</returns>
        /// <param name="reference">The requested reference name</param>
        /// <param name="index">The index of this reference</param>
        protected override IModelElement GetModelElementForReference(string reference, int index)
        {
            if ((reference == "ETYPEPARAMETERS"))
            {
                if ((index < this.ETypeParameters.Count))
                {
                    return this.ETypeParameters[index];
                }
                else
                {
                    return null;
                }
            }
            return base.GetModelElementForReference(reference, index);
        }

        /// <summary>
        /// Resolves the given attribute name
        /// </summary>
        /// <returns>The attribute value or null if it could not be found</returns>
        /// <param name="attribute">The requested attribute name</param>
        /// <param name="index">The index of this attribute</param>
        protected override object GetAttributeValue(string attribute, int index)
        {
            if ((attribute == "INSTANCECLASSNAME"))
            {
                return this.InstanceClassName;
            }
            if ((attribute == "INSTANCETYPENAME"))
            {
                return this.InstanceTypeName;
            }
            return base.GetAttributeValue(attribute, index);
        }

        /// <summary>
        /// Gets the Model element collection for the given feature
        /// </summary>
        /// <returns>A non-generic list of elements</returns>
        /// <param name="feature">The requested feature</param>
        protected override System.Collections.IList GetCollectionForFeature(string feature)
        {
            if ((feature == "ETYPEPARAMETERS"))
            {
                return this._eTypeParameters;
            }
            return base.GetCollectionForFeature(feature);
        }

        /// <summary>
        /// Sets a value to the given feature
        /// </summary>
        /// <param name="feature">The requested feature</param>
        /// <param name="value">The value that should be set to that feature</param>
        protected override void SetFeature(string feature, object value)
        {
            if ((feature == "EPACKAGE"))
            {
                this.EPackage = ((IEPackage)(value));
                return;
            }
            if ((feature == "INSTANCECLASSNAME"))
            {
                this.InstanceClassName = ((string)(value));
                return;
            }
            if ((feature == "INSTANCETYPENAME"))
            {
                this.InstanceTypeName = ((string)(value));
                return;
            }
            base.SetFeature(feature, value);
        }

        /// <summary>
        /// Gets the property expression for the given attribute
        /// </summary>
        /// <returns>An incremental property expression</returns>
        /// <param name="attribute">The requested attribute in upper case</param>
        protected override NMF.Expressions.INotifyExpression<object> GetExpressionForAttribute(string attribute)
        {
            if ((attribute == "EPACKAGE"))
            {
                return new EPackageProxy(this);
            }
            return base.GetExpressionForAttribute(attribute);
        }

        /// <summary>
        /// Gets the property expression for the given reference
        /// </summary>
        /// <returns>An incremental property expression</returns>
        /// <param name="reference">The requested reference in upper case</param>
        protected override NMF.Expressions.INotifyExpression<NMF.Models.IModelElement> GetExpressionForReference(string reference)
        {
            if ((reference == "EPACKAGE"))
            {
                return new EPackageProxy(this);
            }
            return base.GetExpressionForReference(reference);
        }

        /// <summary>
        /// Gets the Class for this model element
        /// </summary>
        public override IClass GetClass()
        {
            if ((_classInstance == null))
            {
                _classInstance = ((IClass)(MetaRepository.Instance.Resolve("http://www.eclipse.org/emf/2002/Ecore#//EClassifier/")));
            }
            return _classInstance;
        }

        /// <summary>
        /// The collection class to to represent the children of the EClassifier class
        /// </summary>
        public class EClassifierChildrenCollection : ReferenceCollection, ICollectionExpression<IModelElement>, ICollection<IModelElement>
        {

            private EClassifier _parent;

            /// <summary>
            /// Creates a new instance
            /// </summary>
            public EClassifierChildrenCollection(EClassifier parent)
            {
                this._parent = parent;
            }

            /// <summary>
            /// Gets the amount of elements contained in this collection
            /// </summary>
            public override int Count
            {
                get
                {
                    int count = 0;
                    count = (count + this._parent.ETypeParameters.Count);
                    return count;
                }
            }

            protected override void AttachCore()
            {
                this._parent.ETypeParameters.AsNotifiable().CollectionChanged += this.PropagateCollectionChanges;
            }

            protected override void DetachCore()
            {
                this._parent.ETypeParameters.AsNotifiable().CollectionChanged -= this.PropagateCollectionChanges;
            }

            /// <summary>
            /// Adds the given element to the collection
            /// </summary>
            /// <param name="item">The item to add</param>
            public override void Add(IModelElement item)
            {
                IETypeParameter eTypeParametersCasted = item.As<IETypeParameter>();
                if ((eTypeParametersCasted != null))
                {
                    this._parent.ETypeParameters.Add(eTypeParametersCasted);
                }
            }

            /// <summary>
            /// Clears the collection and resets all references that implement it.
            /// </summary>
            public override void Clear()
            {
                this._parent.ETypeParameters.Clear();
            }

            /// <summary>
            /// Gets a value indicating whether the given element is contained in the collection
            /// </summary>
            /// <returns>True, if it is contained, otherwise False</returns>
            /// <param name="item">The item that should be looked out for</param>
            public override bool Contains(IModelElement item)
            {
                if (this._parent.ETypeParameters.Contains(item))
                {
                    return true;
                }
                return false;
            }

            /// <summary>
            /// Copies the contents of the collection to the given array starting from the given array index
            /// </summary>
            /// <param name="array">The array in which the elements should be copied</param>
            /// <param name="arrayIndex">The starting index</param>
            public override void CopyTo(IModelElement[] array, int arrayIndex)
            {
                IEnumerator<IModelElement> eTypeParametersEnumerator = this._parent.ETypeParameters.GetEnumerator();
                try
                {
                    for (
                    ; eTypeParametersEnumerator.MoveNext();
                    )
                    {
                        array[arrayIndex] = eTypeParametersEnumerator.Current;
                        arrayIndex = (arrayIndex + 1);
                    }
                }
                finally
                {
                    eTypeParametersEnumerator.Dispose();
                }
            }

            /// <summary>
            /// Removes the given item from the collection
            /// </summary>
            /// <returns>True, if the item was removed, otherwise False</returns>
            /// <param name="item">The item that should be removed</param>
            public override bool Remove(IModelElement item)
            {
                IETypeParameter eTypeParameterItem = item.As<IETypeParameter>();
                if (((eTypeParameterItem != null)
                            && this._parent.ETypeParameters.Remove(eTypeParameterItem)))
                {
                    return true;
                }
                return false;
            }

            /// <summary>
            /// Gets an enumerator that enumerates the collection
            /// </summary>
            /// <returns>A generic enumerator</returns>
            public override IEnumerator<IModelElement> GetEnumerator()
            {
                return Enumerable.Empty<IModelElement>().Concat(this._parent.ETypeParameters).GetEnumerator();
            }
        }

        /// <summary>
        /// The collection class to to represent the children of the EClassifier class
        /// </summary>
        public class EClassifierReferencedElementsCollection : ReferenceCollection, ICollectionExpression<IModelElement>, ICollection<IModelElement>
        {

            private EClassifier _parent;

            /// <summary>
            /// Creates a new instance
            /// </summary>
            public EClassifierReferencedElementsCollection(EClassifier parent)
            {
                this._parent = parent;
            }

            /// <summary>
            /// Gets the amount of elements contained in this collection
            /// </summary>
            public override int Count
            {
                get
                {
                    int count = 0;
                    if ((this._parent.EPackage != null))
                    {
                        count = (count + 1);
                    }
                    count = (count + this._parent.ETypeParameters.Count);
                    return count;
                }
            }

            protected override void AttachCore()
            {
                this._parent.EPackageChanged += this.PropagateValueChanges;
                this._parent.ETypeParameters.AsNotifiable().CollectionChanged += this.PropagateCollectionChanges;
            }

            protected override void DetachCore()
            {
                this._parent.EPackageChanged -= this.PropagateValueChanges;
                this._parent.ETypeParameters.AsNotifiable().CollectionChanged -= this.PropagateCollectionChanges;
            }

            /// <summary>
            /// Adds the given element to the collection
            /// </summary>
            /// <param name="item">The item to add</param>
            public override void Add(IModelElement item)
            {
                if ((this._parent.EPackage == null))
                {
                    IEPackage ePackageCasted = item.As<IEPackage>();
                    if ((ePackageCasted != null))
                    {
                        this._parent.EPackage = ePackageCasted;
                        return;
                    }
                }
                IETypeParameter eTypeParametersCasted = item.As<IETypeParameter>();
                if ((eTypeParametersCasted != null))
                {
                    this._parent.ETypeParameters.Add(eTypeParametersCasted);
                }
            }

            /// <summary>
            /// Clears the collection and resets all references that implement it.
            /// </summary>
            public override void Clear()
            {
                this._parent.EPackage = null;
                this._parent.ETypeParameters.Clear();
            }

            /// <summary>
            /// Gets a value indicating whether the given element is contained in the collection
            /// </summary>
            /// <returns>True, if it is contained, otherwise False</returns>
            /// <param name="item">The item that should be looked out for</param>
            public override bool Contains(IModelElement item)
            {
                if ((item == this._parent.EPackage))
                {
                    return true;
                }
                if (this._parent.ETypeParameters.Contains(item))
                {
                    return true;
                }
                return false;
            }

            /// <summary>
            /// Copies the contents of the collection to the given array starting from the given array index
            /// </summary>
            /// <param name="array">The array in which the elements should be copied</param>
            /// <param name="arrayIndex">The starting index</param>
            public override void CopyTo(IModelElement[] array, int arrayIndex)
            {
                if ((this._parent.EPackage != null))
                {
                    array[arrayIndex] = this._parent.EPackage;
                    arrayIndex = (arrayIndex + 1);
                }
                IEnumerator<IModelElement> eTypeParametersEnumerator = this._parent.ETypeParameters.GetEnumerator();
                try
                {
                    for (
                    ; eTypeParametersEnumerator.MoveNext();
                    )
                    {
                        array[arrayIndex] = eTypeParametersEnumerator.Current;
                        arrayIndex = (arrayIndex + 1);
                    }
                }
                finally
                {
                    eTypeParametersEnumerator.Dispose();
                }
            }

            /// <summary>
            /// Removes the given item from the collection
            /// </summary>
            /// <returns>True, if the item was removed, otherwise False</returns>
            /// <param name="item">The item that should be removed</param>
            public override bool Remove(IModelElement item)
            {
                if ((this._parent.EPackage == item))
                {
                    this._parent.EPackage = null;
                    return true;
                }
                IETypeParameter eTypeParameterItem = item.As<IETypeParameter>();
                if (((eTypeParameterItem != null)
                            && this._parent.ETypeParameters.Remove(eTypeParameterItem)))
                {
                    return true;
                }
                return false;
            }

            /// <summary>
            /// Gets an enumerator that enumerates the collection
            /// </summary>
            /// <returns>A generic enumerator</returns>
            public override IEnumerator<IModelElement> GetEnumerator()
            {
                return Enumerable.Empty<IModelElement>().Concat(this._parent.EPackage).Concat(this._parent.ETypeParameters).GetEnumerator();
            }
        }

        /// <summary>
        /// Represents a proxy to represent an incremental access to the instanceClassName property
        /// </summary>
        private sealed class InstanceClassNameProxy : ModelPropertyChange<IEClassifier, string>
        {

            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public InstanceClassNameProxy(IEClassifier modelElement) :
                    base(modelElement)
            {
            }

            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override string Value
            {
                get
                {
                    return this.ModelElement.InstanceClassName;
                }
                set
                {
                    this.ModelElement.InstanceClassName = value;
                }
            }

            /// <summary>
            /// Registers an event handler to subscribe specifically on the changed event for this property
            /// </summary>
            /// <param name="handler">The handler that should be subscribed to the property change event</param>
            protected override void RegisterChangeEventHandler(System.EventHandler<NMF.Expressions.ValueChangedEventArgs> handler)
            {
                this.ModelElement.InstanceClassNameChanged += handler;
            }

            /// <summary>
            /// Registers an event handler to subscribe specifically on the changed event for this property
            /// </summary>
            /// <param name="handler">The handler that should be unsubscribed from the property change event</param>
            protected override void UnregisterChangeEventHandler(System.EventHandler<NMF.Expressions.ValueChangedEventArgs> handler)
            {
                this.ModelElement.InstanceClassNameChanged -= handler;
            }
        }

        /// <summary>
        /// Represents a proxy to represent an incremental access to the instanceTypeName property
        /// </summary>
        private sealed class InstanceTypeNameProxy : ModelPropertyChange<IEClassifier, string>
        {

            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public InstanceTypeNameProxy(IEClassifier modelElement) :
                    base(modelElement)
            {
            }

            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override string Value
            {
                get
                {
                    return this.ModelElement.InstanceTypeName;
                }
                set
                {
                    this.ModelElement.InstanceTypeName = value;
                }
            }

            /// <summary>
            /// Registers an event handler to subscribe specifically on the changed event for this property
            /// </summary>
            /// <param name="handler">The handler that should be subscribed to the property change event</param>
            protected override void RegisterChangeEventHandler(System.EventHandler<NMF.Expressions.ValueChangedEventArgs> handler)
            {
                this.ModelElement.InstanceTypeNameChanged += handler;
            }

            /// <summary>
            /// Registers an event handler to subscribe specifically on the changed event for this property
            /// </summary>
            /// <param name="handler">The handler that should be unsubscribed from the property change event</param>
            protected override void UnregisterChangeEventHandler(System.EventHandler<NMF.Expressions.ValueChangedEventArgs> handler)
            {
                this.ModelElement.InstanceTypeNameChanged -= handler;
            }
        }

        /// <summary>
        /// Represents a proxy to represent an incremental access to the ePackage property
        /// </summary>
        private sealed class EPackageProxy : ModelPropertyChange<IEClassifier, IEPackage>
        {

            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public EPackageProxy(IEClassifier modelElement) :
                    base(modelElement)
            {
            }

            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override IEPackage Value
            {
                get
                {
                    return this.ModelElement.EPackage;
                }
                set
                {
                    this.ModelElement.EPackage = value;
                }
            }

            /// <summary>
            /// Registers an event handler to subscribe specifically on the changed event for this property
            /// </summary>
            /// <param name="handler">The handler that should be subscribed to the property change event</param>
            protected override void RegisterChangeEventHandler(System.EventHandler<NMF.Expressions.ValueChangedEventArgs> handler)
            {
                this.ModelElement.EPackageChanged += handler;
            }

            /// <summary>
            /// Registers an event handler to subscribe specifically on the changed event for this property
            /// </summary>
            /// <param name="handler">The handler that should be unsubscribed from the property change event</param>
            protected override void UnregisterChangeEventHandler(System.EventHandler<NMF.Expressions.ValueChangedEventArgs> handler)
            {
                this.ModelElement.EPackageChanged -= handler;
            }
        }
    }
}

redpajama_set_name: RedPajamaGithub


January's market rally is starting to fizzle out, with trade war and worries of global slowdown threatening to disrupt stock gains. With volatility likely to return to the bourses, investors will seek out defensive options, which offer higher income levels at slightly higher risk than bonds, whose attractiveness is set to decline.
Real estate investment trusts (REITs) fit the bill easily with their consistent, high income streams. They offer a simple way for individual investors to park their money in commercial real estate.
Further, they are legally mandated to distribute the majority of their income as dividends. Investing in REITs offering substantially high dividends looks prudent.
REITs are possibly the first and most convenient option for investors looking for regular income. Firstly, they legally pay out 90% of their income as dividends to investors. In reality, most of them distribute nearly all of their taxable income.
Further, compared to traditional stocks, REITs offer twice the amount of payouts. This is what leads to their reputation as steady income creators. And unlike their fixed income counterparts, they can raise their dividend payouts year after year.
As we enter 2019, equity markets are facing a number of headwinds. Trade tensions with China and tighter monetary policy from the world's central banks are combining to put the brakes on global growth. At the same time, the domestic economy remains strong enough to stave off a recession.
REITs would make for great additions to your portfolio under such circumstances because of their steady income streams. Per the National Association of Real Estate Investment Trusts', (Nareit) Calvin Schnure, REITs are exhibiting sturdy gains in funds from operations (FFOs) and healthy occupancy rates.
One major disadvantage of REITs is that they are a rate-sensitive class of securities. It comes as no surprise that they have flourished during a low environment. And the latest signals from the Fed indicate that this could continue for an extended period given that signs are strong that the economy is slowing.
Incidentally, even as rates are set to remain low in the medium term, REITs as a class have been steadily reducing their exposure to possible rate hikes, according to Schnure.
Further, strong economic growth can fuel gains for REITs even in a rising rate environment, as demonstrated by Nareit data. This is because strong economic conditions boost the industry's earnings and share prices.
As we progress further into 2019, U.S. equity markets are facing a number of headwinds. But while the pace of growth is likely to fall off, a full-blown recession seems unlikely. REITs are an ideal class of stocks to generate steady income levels under such conditions.
This is why it makes good sense to add them to your portfolios. However, picking winning stocks may be difficult.
Ready Capital Corporation RC is a publicly traded mortgage REIT which finances real estate operations.
Ready Capital carries a Zacks Rank #1 (Strong Buy) and has a VGM Score of A. The Zacks Consensus Estimate for the current year has improved by 1.1% over the last 30 days. The stock has a dividend yield of 10.1%.
Sotherly Hotels Inc. SOHO is a lodging REIT which is self-administered and self-managed.
Sotherly Hotels has a VGM Score of A. The company's expected earnings growth for the current year is 9.7%. The stock has a dividend yield of 7.2%. The stock sports a Zacks Rank #1. You can see the complete list of today's Zacks #1 Rank stocks here.
Bluerock Residential Growth REIT, Inc. BRG is a REIT which acquires apartment properties in demographically attractive growth markets throughout the United States.
Bluerock Residential has a Zacks Rank #2 (Buy) and VGM Score of A. The company has expected earnings growth of 10.7% for the current year. The stock has a dividend yield of 6.4%.
City Office REIT, Inc. CIO is a REIT which focuses on acquiring, owning, and operating office properties in the United States.
City Office REIT carries a Zacks Rank #2 and has a VGM Score of B. The company's expected earnings growth for the current year is 12.8%. The stock has a dividend yield of 8%.
Exantas Capital Corp. XAN is a REIT which provides commercial real estate loans and credit investments such as commercial mortgage-backed securities.
Exantas Capital carries a Zacks Rank #2 and has a VGM Score of B. The company's expected earnings growth for the current year is 45.7%. The stock has a dividend yield of 6.5%.


text:
Hinchinbrook Island
Hinchinbrook Island National Park Tropical North Queensland
The rugged beauty of Hinchinbrook Island National Park must be seen to be believed! Photo credit: Maxime Coquard © Tourism and Events Queensland
Agnes Beach camping area
Banksia Bay camping area
Banshee Bay camping area
George Point camping area
Mulligan Bay camping area
North Macushla camping area
North Zoe Bay camping area
Sea Kayaking camping area
South Macushla camping area
South Zoe Bay camping area
Sunset Beach camping area
The Haven (Scraggy Point) camping area
North Shepherd Bay track
South Shepherd Bay track
Thorsborne Trail
George Point day-use area
North Macushla day-use area
South Macushla day-use area
South Zoe Bay day-use area
The Haven day-use area
About Hinchinbrook Island
Protected since 1932, Hinchinbrook Island is one of Australia's largest island national parks (39,900ha). It is within the Great Barrier Reef World Heritage Area and is separated from the mainland by the scenic Hinchinbrook Channel.
Surrounded by marine park waters, the fringing reefs and seagrass beds are home to some vulnerable species, including dugong and green turtles.
Hinchinbrook Island is renowned for its range of habitats including misty, heath-covered mountains sandy beaches, paperbark and palm wetlands, and extensive woodlands. Patches of lush rainforest and eucalypt forest descend to a mangrove-fringed channel in the west, with sweeping bays and rocky headlands along the east coast. The island's mangrove forests are some of the richest and most varied in Australia and are an important breeding ground for many marine animals.
For thousands of years the Bandjin Aboriginal people lived on Hinchinbrook Island. Middens and fish traps are reminders of their special culture.
The island's Thorsborne Trail is recognised world-wide and was named after local naturalists Margaret and Arthur Thorsborne.
Read more information about the nature, culture and history of Hinchinbrook Island National Park.
Flights within 1500 vertical feet above ground or sea level are not permitted over Hinchinbrook Island. See the aircraft operators information sheet or the Hinchinbrook Plan of Management for more information.
Do not feed the animals, including fish—it can affect their health and alter the natural population balance.
Domestic animals are not permitted on Hinchinbrook Island National Park or on tidal lands, including beaches, rocks, mangrove areas and dunes, within the Great Barrier Reef Coast Marine Park.
Lighting fires is prohibited. Please bring fuel stoves
Take rubbish with you when you leave.
When boating, go slowly over seagrass beds—dugongs feed here.
In areas where toilets are not provided, bury human waste at least 15cm deep and 100m from watercourses, tracks and camping areas.
Take all sanitary items, including disposable nappies with you, as they do not decompose.
Everything in the park is protected. Please leave everything as you found it.
Queensland Parks and Wildlife Service (QPWS) manages Hinchinbrook Island National Park to preserve the area's natural, cultural and scenic values. Over most of the island, only self-reliant, nature-based and ecologically sustainable recreation is permitted. The majority of the natural environment remains undisturbed and preserved under various acts, legislation and management policies.
The Hinchinbrook Island National Park management plan (PDF, 2.6MB) guides the management of the park and, to help with the protection and integrity of the coastal areas, the Cardwell–Hinchinbrook Regional Coastal management plan has been developed.
To help with the protection and integrity of the coastal areas surrounding the park a Cardwell–Hinchinbrook regional coastal management plan has been developed.
Hinchinbrook Island National Park lies within the Great Barrier Reef World Heritage Area. Management of the World Heritage Area is coordinated through a partnership between the Commonwealth and Queensland governments, the Traditional Owners and the wider community.
GBRMPA has implemented the Hinchinbrook Plan of Management in partnership with local communities through the Hinchinbrook Local Advisory Committee. This plan ensures best practices within the marine park enabling sustainable use and preservation for future generations. This plan covers activities within the marine park, including vessel size limits, area access, use of various water sports, aircrafts, commercial use and tourism activities.
Rainforest and Reef Information Centre
www.greatgreenwaytourism.com
Cardwell Qld 4849
Email: info@greatgreenwaytoursim.com
Townsville Bulletin Square Visitor Information Centre
www.townsvillenorthqueensland.com.au
Flinders Street
Townsville City Qld 4810
ph (07) 4721 3660 or 1800 801 902
email flinders@tel.com.au
The natural, cultural and historical significance of Hinchinbrook Island


Those weary of the on-going acclaim for sophisticated graphic novels -- essentially comic books for adults with layered novelistic narratives and innovative graphic design -- will welcome this fat, old school collection of a dozen 60s comic books from the Commando series chosen by the magazine's longtime editor George Low.
Here are simple yarns of derring-do from the Second World War where the Germans are referred to as the Hun, Boche, Jerries, squareheads and so on (often with adjectives like cruel, hate-filled, nasty) and Italians are "Eyeties". British troops on the other hand are the Royal Westshires and the Cornshires, take their orders from Whitehall, and have nicknames like Titch and Cobber.
Yugoslav patriots charge the enemy with ringing phrases such as, "Death to the nazis, defilers of our country".
You get the picture: this world is less complex place, the lines between friend and foe are as defined as a uniform (although in one story two brave Tommies don German gear to sneak into an enemy camp), and good men either die young and heroically, or win the day.
No women clutter up the action or complicate matters.
Told in simple frames (no jagged edges or unframed art as in graphic novels) these are simple, although not simplistic stories, which are pure escapism, but come with what we might today see overt racism in the stereotypes.
Yet the work by the anonymous artists is dramatic and -- when it comes to guns, tanks, artillery and aircraft -- rendered with an eye for detail. The stories also have plot twists worthy of any classic war film and Commando, launched in 1961, is so successful it is still published today.
Leave this one on the coffee table and you'll get reactions from "Wow, I used to read Commando!" to PC-friends and sensitive guests strongly objecting to it.
If nothing else, The Dirty Dozen will be a conversation starter.


text:
Prep football: Desert Hills escapes with win over Cedar on missed kick
rmiller4@thespectrum.com
With 40 seconds remaining, all Desert Hills could do was hope and pray.
The Thunder were holding tightly to a one-point lead, but Cedar was in a position to go for the win. The Redmen called upon kicker Blake White-Schreibman, who made a 42-yard field goal earlier in the game, to win the game for them.
His 32-yard attempt hooked left, and Desert Hill escaped with an 18-17 victory over Cedar in both team's 3AA South region opener.
"That's the most intense game I've ever been a part of," Desert Hills quarterback Quinn Kiser said.
Desert Hills trailed 17-6 in the second half when Kiser finally got going. The Thunder offense had been suffocated by Cedar's defense in the first half, with the Redmen holding Kiser to just 11 passing yards. So when Cedar quarterback Mason Fakahua found Derek Ball for a 30-yard touchdown midway through the third quarter, it looked like the Redmen were about to pull away.
Kiser didn't let that happen.
The Thunder quarterback hit Logan Hokanson on a 20-yard touchdown just before the third quarter ended to cut the Cedar lead to 17-12. And then with 6:14 remaining in the game, he connected with Braxton Porter for a 21-yard touchdown to give the Thunder their first lead of the game.
"The defense played their hearts out," Kiser said. "I struggled so bad in the first half, but we are never going to give up and you can never count us out. I just love the guys on my team. It's just a strong brotherhood."
While the result was a positive one for Desert Hills, head coach Carl Franke wasn't too pleased with how his team got it. The Thunder came out of the gates sloppy and the first half was filled with mistakes, bad reads and penalty after penalty.
"I'm just not happy with the way we played at all," Franke said. "Zero happiness, right now. A win's a win and it's great, but we just can't come off the bus playing like that. That's just not us. It's just a frustrating deal. Even with a win, it's hard to make me happy, but this one I'm not happy with."
Cedar took just a 10-6 lead into halftime, but if it wasn't for the Thunder defense that lead might have been much bigger. The Thunder did a good job bottling up Fakahua and making him beat them with his arm. He succeeded at times — he converted a 3rd-and-20 by finding Braden Garrett for a 35-yard touchdown in the first quarter for the first points of the game — but there were times he struggled, too.
Desert Hills Nephi Sewell intercepted Fakahua and ran it back in for a touchdown for the only Thunder points of the first half.
"Our defense played, I thought, awesome all night," Franke said.
And that defense allowed Kiser and the Thunder offense time to find their rhythm.
"I felt like I let my team down in the first half," Kiser said. "I know the kids on my team look up to me — senior quarterback, captain — I had to put the team on my back and trust my guys to make plays and they did. They did just what I needed them to do."
And the Thunder did just enough to escape Cedar with a region-opening win.
"That kid's a helluva kicker and I wish that he could feel they I do right now," Kiser said of White-Schreibman. "I hope he can keep his head up. There's nothing to hang his head about. He's got so many more kicks that he will make."
Follow Ryan Miller on Twitter, @millerjryan.