The Audi R8 has been the fastest production car in the Audi lineup for quite some time. Yet, it has taken a step ahead at the 2014 Los Angeles Auto Show to offer the fastest R8 todate. The German automaker displayed the limited edition 2015 R8 Competition with an engine upgrade and a little makeover.
The new 48-volt technology from Audi has made things even more powerful and efficient. Most cars are seen to use a 12-volt system to supply power to their electrical systems. However, with an increasing number of electric elements being added to new vehicles, it seems 12 volts is not going to be enough. Audi seems to have realized this fast enough and introduces the electrifying 48-volt technology.
Audi is an automobile manufacturer which is specialized in designing, producing and distribution of automobiles. There is no doubt that Audi is continually preoccupied with lightning. Now Audi is introducing Audi R8 LMX super sports car with laser headlights which twice the illumination range. It will unveil to the street this summer with a base price in Germany is €210,000. Ground breaking and breathtaking performance technology assembled into an efficient R8 LMX road car ever produced in the history of Audi. Audi R8 LMX is more efficient than all previous models. And cover 100 km/h (62.1 mph) in three to four seconds and consume 12.9 liters fuel per 100 kilometers It is the Audi who first developed the automotive lightening technology. It is equipped with high laser beam which substantially increase the range.
Audi S1 is making its comeback but in a new style that is city car. We all know that Audi S1 is a legendary name for the bobble hat enthusiasts but this time it is making its entry to the market as a city car. Audi decided to present the legendary S1 in two styles: S1 and S1 sportback as new flagship in Audi's compact A1 line. Both models are equipped with a 2.0 TFSI produces 231 horsepower (170 kW) and 272.90 lb ft of torque (370 NM). All wheel drive is standard on both models and extensively revamped suspension is added to ensure a smooth and quality ride. In 1980 an Audi S1 made a legendary reputation across the world for its distinctive and dominant performance and now once again Audi is presenting two models and Audi tried its level best to offer the same sophistication and precision that they offered in 80s.


text:
September 6, 2017 September 5, 2017 Caelyn Ellis Diversity, original content, religion
Racism in Fighting Games – Gar Atkins
I grew up in what some might call the tail end of the golden age of the arcade. Back before netplay was commonplace and home consoles had the power to deliver the latest gaming experience, the arcade was the place to go. It was the noisy, flashy, stim-filled place to see where the future of video games was going, and talk to people that shared your interests. I know I spent hours chatting over the latest rumors you heard from this guy who had an uncle that totally worked at Nintendo.
The centerpiece of this ecosystem, the metaphorical waterhole that everyone gathered around in my experience was the fighting game. The actual game might have changed depending on the year and location from things like Street Fighter, to Mortal Kombat, to Tekken, but it was a constant. And no matter the game there was a sense of community as you watched that one kid pull off that one special move you didn't even know existed.
But growing up as a Native American there was something that always bothered me. As a kid, I didn't always have the words to express it but it was there nonetheless, constant toxic background radiation. But now I'm an adult with more words at my disposal, and fighting games are experiencing a mainstream resurgence, so it's time to talk.
Fighting games have an issue with racism
Now, on the whole I don't think this comes from an intentionally malicious place, but rather cultural ignorance or neglect. Often in an attempt to make this global diverse cast they paint these characters in broad and sometimes very harmful strokes in an attempt to make them recognizable. Nativeness is in fighting games, and to some extent, video games as a whole is often defined as the same unspecific aesthetic full of face paint, eagle feathers, and a sour scowl. Nativeness in video games is not allowed to be happy, laugh, or eager. No nation is ever named for nativeness in video games, just a vague desert-y place somewhere in southwest. Luckily they have spirit-themed powers to help them combat their advisories.
While there is a wider conversation there, there is a certain thread that bother me as a Native man. These are the archetypes of the "Noble Savage" and "Mystic Shaman". Now other First Nations readers may recognize this as part of of what we call the "unholy trinity of bad Native rep" alongside the gag-worthy "Native princess".
You've probably seen the noble savage. You know it's him by his scowling glare of stoicism, often staring into the middle distance of a canyon of some kind. He's rough and rude, but has a code of honor that's never really defined. He's usually good with animals and sometimes armed with flint weapons straight out of a museum. He talks about time in terms of "many moons" like we don't have calendars, and lacks the ability to use contractions.
It's a harsh profile. Casting us simultaneously as this fetishized symbol of warrior strength and crude, brutish primitives that are stuck in the past. It's reductive, turning us into a props and mascots instead of modern members of communities and still-living cultures with likes, interests and talents of our own. A good example of this sort of character T.Hawk from Street Fighter or, to a lesser extent, Wolf from Virtua Fighter, though every character in this article shows some aspects of this.
T.Hawk is a special kind of character, to the point he could pretty much serve as an example of what you should absolutely not do in your games representation of Native Americans. Some of you might write this off as "Well, Capcom is a Japanese company" as if like Capcom lack Western localization teams or hasn't been selling to a Western market for decades. Nevertheless, T. Hawk's voice actors are still spouting such gems as "Your scream sounds like a pathetic war cry!" and "It has been many moons since I've had this much fun." Even if Capcom, an internationally established video game company, doesn't get the finer points of Western culture, or that they treat everyone with that amount of carelessness, It doesn't remove their responsibility or excuse poor or harmful portrayals. Media doesn't exist in a bubble and still affects those it portrays no matter its origin.
Gathering research for this article, the more I saw of T.Hawk, his weird use of feathers as an accessory with no meaning, and his ultra combo where he sits cross-legged on his opponent's back and gives the Hollywood Indian "How", the more I kept thinking about all those stories of Western developers having to program in an additional finger to their mascot character platformers as to not offend a Japanese audience with implications of Yakuza activity. Just ask the developers of Oddworld: Abe's Oddysee or Psychonauts.
Western media is not blameless in this either, in fact I'd postulate that most of this bad rep is a reflection and regurgitation of Western media, including games. Take Mortal Kombat and its character of Nightwolf, who is kind of a mixed bag. On the positive side of things, Nightwolf has an actual named and non-fictional nation he belongs to, the Apache (though I will note that they refer to themselves as Ndee and Apache means"enemy" in Zuni). He's canonically a historian, implying a college education when showing Native American character possessed of a higher education is appallingly rare in any medium. He even got to be the smart guy of the team in the cartoon Mortal Kombat: Defenders of the Realm. His dialog and win screens do include acknowledgements of colonialism instead of neatly shooing it away from the Native experience, even if it is very clearly written from a white perspective.
There is a lot of emphasis on him winning back his lands if he wins the tournament, which is a weird trend I keep noticing in the stories of these characters. Part of me is all for an ultimate expression of Native sovereignty, but there is a narrative tendency to treat Native lands as a prize to be won instead of their loss being a result of a campaign of genocide and imperialism.
But at the same time Nightwolf is more or less the perfect example of the Mystic Shaman archetype. It's an archetype that occupies the same place as the wise black man in giving spiritual advice to typically white folks that need guidance. Most of the time this involves a lot of talk about spirit animals and vague undefined and non secular rambling about nature, gods and fate. It trivialises and exotifies Native beliefs and spirituality, which are, contrary to popular belief, living religions. Not to mention these portrayals tend to lack research and present nebulous spiritualities that are a hodgepodge of various cultures and plain fabrications they've pulled out of nowhere.
Nowhere is the more apparent than in Mortal Kombat Annihilation, a movie where Nightwolf's motivation appears to be to prance and menace like a character from Andrew Lloyd Webber's Cats. I suppose he's also there to administer some sort of spiritual mojo trip so Liu Kang can discover his spirit animal, sorry, "animality" before disappearing for the rest of the film.
Around the PS2-era they tried to add some legitimacy by making him a kind of sin-eater, which is an idea you see in religions and folklore of a figure that absorbs the sins and faults of others on their behalf. It is certainly a more specific role and has a history in the region, though I can not speak with certainty about Ndee beliefs as they are not my nation. I suspect, due to my experience as a Tsalagi man, it's severely misused, particularly as you usually see it tied to funerary rights, but at least they seemed to put some effort into trying.
Come the 2011 reboot they just gave up and actually came back with worse representation than they had in the 90's, which is certainly a feat. His ending in Mortal Kombat (2011) has Nightwolf defeating Shao Kahn with the aid of his spirit animal, a concept not really as omnipresent in Native spirituality as pop culture seems to think it is. This spirit guide is lost, corrupted by the villain Shao Khan, and eventually re-summoned by elders on behalf of Nightwolf. Of course this leads to Nightwolf, in the most Mortal Kombat fashion possible, being corrupted by Shao Khan and turning into a werewolf that proceeds to transform the planet into subservient werewolves. It's a long way away from, yet weirdly reminiscent, of his trilogy ending where he becomes a leader of the free world.
And I get it. Mortal Kombat has and always will have its roots in exploitation, but I stress that developers should at least be aware of who and what you're actually exploiting lest you run into the same issues as the late era blaxploitation and kung fu films the game took its influences from. I guess I should be thankful that at least they didn't call it a skinwalker or something and that it's not the canon ending.
Currently in the Mortal Kombat timeline Nightwolf has been relegated to an undead jobber. For those of you not familiar with wrestling, a jobber is a guy they bring out to lose to other guys to make them look big and strong. Think Worf on Star Trek.
It you want a better way to do this, you should look towards Thunder from Killer Instinct. 90's Thunder was pure bad and embodied a lot of the negative stuff discussed in this essay, complete with stone-headed axes and a mohawk made of feathers. But Rare realized in the reboot of this franchise that there is better way of going about this. They ditched the vague and offensive exploitation Indian look for one that not only invoked and took after a specific named nation (Nez Perce), but did so under the guidance of a paid cultural consultant from the Nez Perce. Which, in my opinion, is the least you could do when you're working with any culture you're not familiar with. They also had the character of Thunder speak Niimi'puutimt, the traditional language of the Nez Perce, which is a nice touch and super important given its critically endangered status.
There is still a bit of an issue with relying on the problematic archetypes I've talked about and a lot of iffy uses of Native spirituality, but this is certainly better than most of what's out there. Personally, I think there is a big issue with Native stories in media in their inability to tell stories that picture Native characters after the Old West, at least outside of Native-made media. It adds to this narrative that we're dead or a part of the past that doesn't matter anymore.
If you're going to take anything from this essay I hope it would be the following: Know what you're writing or representing, or find someone who does and listen to them. If you're making a Native character in your fighting game and you wish to make them a stoic warrior or wise shaman of some kind, are you doing it because it's what the character needs or because they're Native? Native characters are just as capable of holding up any number of popular fighting game tropes. Are you letting them be characters people can love and relate to, or are you upholding false narratives told by people from the outside of the cultural conversation?
P.S. Maybe make a woman or two?
Gar Atkins (though friends call him Sahoni) is a Bisexual Eastern Band Cherokee writer in Arkansas. Besides writing his hobbies include tabletop game design, art, pop culture hording, and as a amateur folklorist. If you enjoyed this article, let him know by buying him a coffee at ko-fi.com/sahoni or follow him on twitter @sahoni_stuff.
Tagged fighting games, Gar Atkins, racism
Published by Caelyn Ellis
Journalist, writer, gamedev and geek dilettante. Covers games, comics and the realities of being a mentally ill trans lesbian on Rainy Fascism Island. Really loves RPGs of the computer, tabletop and live action variety, and will talk about them way too much if allowed.	View all posts by Caelyn Ellis
7 thoughts on "Racism in Fighting Games – Gar Atkins"
JR Klein says:
I'm a white guy but I agree with you. It seems every fighting game has a "Native American" character who is so stereotypical it makes my eyes roll. And yeah, like you said, females are very rare- the only ones I can think of are Michelle and Julia from the Tekken series.
Gar Atkins says:
You're not the first ones to bring them up! I really wanted to include them in the article, I just couldn't find a way to feasible squeeze them in and add to the conversation. But I did look at them.
Robson Waterkemper says:
Excellent article.
I was curious to know the writers opinion on characters such as Spirit from G.I. Joe and Connor from Assassin's Creed 3.
Thank you so much for reading it! I'm honestly unfamiliar with both characters outside of the names, but I am interested in taking a look at Connor when I have the opportunity to play through the game. AC3 is on a huge list of native games I want to take a look at alongside Infamous Second Son, the original Prey, Turok, and Custard's Last Stand.
As for Spirit? GI Joe was a bit before me, but it's be really cool to see how he was presented in the comics if at all but on the whole it was not a good time for native representation.
Thanks for your reply. I'll be looking for your analysis of Connor in AC3 and perhaps Spirit from G.I. Joe as well.
There were another native character in G.I. Joe mythos, called Airborne.
http://www.yojoe.com/action/83/airborne.shtml
Mozelle Lossett says:
Hello there! This post could not be written any better! Reading this post reminds me of my good old room mate! He always kept talking about this. I will forward this page to him. Pretty sure he will have a good read. Thank you for sharing!|
Kakuzan says:
Very interesting post. I have definitely noticed that both the East and West tend to use foreign cultures as little more than window dressing without really exploring it, especially in regards to vaguely described concepts of "honor".
So You Did Something Gay: What Comes Next? – Benjamin Red
Streaming Update!

redpajama_set_name: RedPajamaCommonCrawl


We are creatively engaging, training, supporting, connecting and inspiring people from all walks of life through the medium of community arts and circus within New Zealand. From at risk youth to industry professionals, we see and believe in the power and benefit of community arts and circus.
We are a dedicated, experienced and passionate inter-disciplinary group based in Auckland, Wellington and Dunedin. We aim to raise the profile of community arts and circus within New Zealand and work with a wide range of people. This work includes support and collaboration with community groups and grassroots organisations and Arts and Circus professionals.
We strive to bring community arts and circus into the hearts of communities and to make them accessible for all.


A colourful artificial flower wedding wand with three beautiful soft touch blue Calla Lilies and light-catching crystals. Underneath the flowers are ivory organza bows, with a yellow satin handle with a silver diamante buckle. Perfect for young bridesmaids, they are easy to hold and lightweight.
Length:- 11.5 inches (including flower head and handle).


Dell 22 Monitor offers a sleek, premium look and exceptional home entertainment experience.
aluminum painted riser create an elegant, modern design perfect for any home environment.
improved bezels almost half as thin as its predecessor.
across a 178° ultrawide viewing angle in Full HD 1920 x 1080 display.


212º The Extra Degree is a must-have in every personal and business library. A Simple Truths #1 bestseller, the concept is simple: At 211º, water is hot. At 212º, it boils. And with boiling water comes steam. And steam can power a locomotive. The one extra degree makes the difference.
We hope that you will join the people, businesses, and schools that have taken action and adopted the 212º concept and used the ONE extra degree to attain their goals.
I handed out 212: The Extra Degree to my staff at our meeting last Monday. I told everyone that I wanted them to read the book while on company time. We held our discussion of the book at this morning's meeting. Everyone was able to take something away from the book and make small adjustments, both in their personal lives and work lives. One of the things that made me happiest is that all staff members have recommended this book to family members, including their children.
Thank you so much for all that you and Simple Truths do. I love your products and appreciate the newsletters that get emailed.
This book was our role out book to our company for a monthly program! It was the perfect one!
The content is good but the printing was poor. Some pages are not easily readable. Expected better quality.
I like the 212 because it allows people to take the principals and apply them not only to real life Management but also to personal improvement.


text:
Thimm produces two innovative POS displays for Ubisoft
NORTHEIM, Germany, Dec. 11, 2019 (Press Release) -Thimm has produced two innovative sales-promoting displays for the big games developer and publisher Ubisoft. In electronics and games retailers two pallet displays are promoting the sales of video games and the ever more popular merchandising items in the gaming sector.
Pankaboard to produce PankaMax hard sized
HELSINKI, Dec. 9, 2019 (Press Release) -PankaMax will be produced with all fiber layers hard sized from beginning of December 2019 onwards.
This means that the Cobb 30 min values are maximum 90 g/m2.
Stora Enso and Sulapac introduce renewable and biodegradable straw
HELSINKI, Dec. 11, 2019 (Press Release) -Stora Enso and Sulapac are launching a renewable and biodegradable straw to combat the global problem of plastic waste. The straw has strong usability and works just like a traditional straw. The new straws are available to brands and consumers looking for more eco-friendly solutions.
Stora Enso enables Stjärnägg switching from plastic to paperboard in egg packaging
HELSINKI, Dec. 3, 2019 (Press Release) -Stjärnägg AB in Sweden is switching from plastic to paperboard in their egg packaging to reduce plastic for environmental reasons. The company supplies fresh eggs from about seventy certified farmers to shops and restaurants across the country and wanted to get rid of unnecessary plastic. The new packaging solution is fully renewable and recyclable.
DS Smith's new study reveals Brits spend 43 days of their lifetime struggling to open packaging
LONDON, Dec. 9, 2019 (Press Release) -
84% have felt frustrated with packaging they couldn't open and more than a third (35%) say problem packaging makes them angry
It's become such a fraught matter that a quarter (25%) have had arguments
Two fifths (39%) of people have even caused themselves an injury navigating problem packaging
Gen Z (aged 18-24) are most likely to suffer frustrations from opening packaging
Model's Zoe & Zazu packaging wins German Design Award 2020
ST. GALLEN, Switzerland, Nov. 25, 2019 (Press Release) -The packaging design "Zoe & Zazu" by Model AG is this year's winner of the German Design Award in the category "Excellent Product Design – Retail". The jury bestows this award on extraordinary packaging designs for retail.
The German Design Award is one of the most acclaimed design competitions worldwide and is growing constantly every year. This year over 5.000 entries were submitted, for the jury to assess.
Lifetime award winner Schwarz's box career was Americana golden-rule simple, packed with innovation
OAKLAND, CA, Dec. 6, 2019 (PPI Pulp & Paper Week) -In a 50-year career where his company grew from three people to one today that generates multi-billion-dollars per year in revenue, Jack Schwarz of Schwarz Partners was honored with the third RISI Lifetime Achievement Award at the International Containerboard Conference (ICC) in Miami Beach on Nov. 14.
The two previous winners were industry icon Roger Stone and Jim Porter, a top WestRock executive today.
BRUSSELS, Dec. 5, 2019 (PPI Europe) -The German Federal Institute for Risk Assessment (BfR) has raised concerns over the potential health risks posed by food contact materials (FCMs) made of melamine-formaldehyde resin (MFH). These include re-useable to-go coffee cups and tableware made with bamboo fibers.
In a position paper released earlier this week, the BfR warns consumers against using this tableware with hot liquids. "The reason is that at higher temperatures, hazardous melamine and formaldehyde can migrate from the material into food," the BfR said.


text:
//
//    Copyright (c) 2006-2018 Erik Ylvisaker
//
//    Permission is hereby granted, free of charge, to any person obtaining a copy
//    of this software and associated documentation files (the "Software"), to deal
//    in the Software without restriction, including without limitation the rights
//    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//    copies of the Software, and to permit persons to whom the Software is
//    furnished to do so, subject to the following conditions:
//
//    The above copyright notice and this permission notice shall be included in all
//    copies or substantial portions of the Software.
//
//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//    SOFTWARE.
//

using AgateLib.Mathematics.Geometry;
using AgateLib.Quality;
using Microsoft.Xna.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;

namespace AgateLib.UserInterface
{
    /// <summary>
    /// Interface for a render element.
    /// </summary>
    public interface IRenderElement : IRenderable
    {
        /// <summary>
        /// Gets the widget display object that contains all the data needed to
        /// render styling and animation of the widget on screen.
        /// </summary>
        RenderElementDisplay Display { get; }

        /// <summary>
        /// Gets a read-only collection of children of this element.
        /// </summary>
        IList<IRenderElement> Children { get; }

        /// <summary>
        /// Gets the parent of this element.
        /// </summary>
        IRenderElement Parent { get; }

        /// <summary>
        /// Gets the type identifier used to identify this render element type to the styling
        /// engine.
        /// </summary>
        string StyleTypeId { get; }

        /// <summary>
        /// Gets the class name used to identify this render element to the styling
        /// </summary>
        string StyleClass { get; }

        /// <summary>
        /// Gets the name of the render element. This is used as the StyleId of the rendered element.
        /// </summary>
        string Name { get; }

        /// <summary>
        /// Gets whether or not the element can receive input focus.
        /// </summary>
        bool CanHaveFocus { get; }

        /// <summary>
        /// Gets whether or not the element currently has input focus.
        /// </summary>
        bool HasFocus { get; }
        /// <summary>
        /// Gets whether or not the element participates in layout.
        /// </summary>
        bool ParticipateInLayout { get; }

        /// <summary>
        /// Gets the aggregated style of the render element.
        /// </summary>
        IRenderElementStyle Style { get; }

        /// <summary>
        /// Gets the props object for the render element.
        /// </summary>
        RenderElementProps Props { get; }

        /// <summary>
        /// Used to track references by the display system.
        /// </summary>
        ElementReference Ref { get; set; }

        /// <summary>
        /// Events for the element.
        /// </summary>
        RenderElementEvents Events { get; }

        ChildReconciliationMode ChildReconciliationMode { get; }

        /// <summary>
        /// Draws the background and border of the element.
        /// </summary>
        /// <param name="renderContext"></param>
        /// <param name="clientDest"></param>
        void DrawBackgroundAndBorder(IUserInterfaceRenderContext renderContext, Rectangle clientArea);

        /// <summary>
        /// Draws the content of the widget.
        /// To draw children, call <c>renderContext.DrawChildren</c>.
        /// </summary>
        /// <param name="renderContext"></param>
        /// <param name="offset"></param>
        void Draw(IUserInterfaceRenderContext renderContext, Rectangle clientArea);

        /// <summary>
        /// Updates the widget.
        /// </summary>
        /// <param name="renderContext"></param>
        void Update(IUserInterfaceRenderContext renderContext);

        /// <summary>
        /// Compute the ideal size of the content of the widget.
        /// </summary>
        /// <param name="layoutContext"></param>
        /// <param name="maxSize"></param>
        /// <returns></returns>
        Size CalcIdealContentSize(IUserInterfaceLayoutContext layoutContext, Size maxSize);

        /// <summary>
        /// Compute the minimum size of the content of the widget, given
        /// a constraint on its height or width.
        /// </summary>
        /// <param name="widthConstraint"></param>
        /// <param name="heightConstraint"></param>
        /// <returns></returns>
        Size CalcMinContentSize(int? widthConstraint, int? heightConstraint);

        /// <summary>
        /// Instructs the element to prepare its layout.
        /// </summary>
        /// <param name="layoutContext"></param>
        /// <param name="contentAreaSize"></param>
        void DoLayout(IUserInterfaceLayoutContext layoutContext, Size contentAreaSize);

        /// <summary>
        /// Called when the element loses focus.
        /// </summary>
        void OnBlur();

        /// <summary>
        /// Called when the element gains focus. If this method returns false, then the element has refused focus.
        /// </summary>
        bool OnFocus();

        /// <summary>
        /// Called when the widget receives an input event.
        /// </summary>
        /// <param name="widgetEventArgs"></param>
        void OnUserInterfaceAction(UserInterfaceActionEventArgs action);

        /// <summary>
        /// Called when a button is pressed.
        /// </summary>
        /// <param name="args"></param>
        void OnButtonDown(ButtonStateEventArgs args);

        /// <summary>
        /// Called when a button is released.
        /// </summary>
        /// <param name="args"></param>
        void OnButtonUp(ButtonStateEventArgs args);

        /// <summary>
        /// Event called by a child component when it receives an input event it cannot handle.
        /// This is usually a navigation event.
        /// </summary>
        /// <param name="menuItemElement"></param>
        /// <param name="btn"></param>
        void OnChildAction(IRenderElement child, UserInterfaceActionEventArgs action);

        /// <summary>
        /// Called by the rendering system when the collection of children is updated.
        /// </summary>
        void OnChildrenUpdated();
        void ReconcileChildren(IRenderElement newNode);

        /// <summary>
        /// Called by the rendering system right before the component is removed from
        /// the render tree.
        /// </summary>
        void OnWillUnmount();

        /// <summary>
        /// Called by the rendering system right after the component
        /// is added to the render tree.
        /// </summary>
        void OnDidMount();

        /// <summary>
        /// Called after reconciliation is complete.
        /// </summary>
        void OnReconciliationCompleted();

        /// <summary>
        /// Sets the props of the render element. This must match the props type used by the render element.
        /// </summary>
        /// <param name="props"></param>
        void SetProps(RenderElementProps props);
    }

    public abstract class RenderElement<TProps> : RenderElement<TProps, object> where TProps : RenderElementProps
    {
        public RenderElement(TProps props) : base(props)
        {
        }
    }

    public abstract class RenderElement<TProps, TState> : IRenderElement where TProps : RenderElementProps
    {
        public RenderElement(TProps props)
        {
            this.Props = props;

            Display = new RenderElementDisplay(this, props);

            ReceiveRenderElementProps();

            EventData = new UserInterfaceEvent(this);
        }

        #region --- Props ---

        public TProps Props { get; private set; }
        RenderElementProps IRenderElement.Props => Props;

        void IRenderElement.SetProps(RenderElementProps props)
        {
            Props = (TProps)props;
            Display.SetProps(props);

            OnReceiveProps();
            TryFinalizeChildren();
        }

        #endregion
        #region --- State ---

        private TState state;
        private IUserInterfaceAppContext appContext;

        public TState State => state;

        protected void ReplaceState(Func<TState, TState> stateMutator)
        {
            SetState(stateMutator(state));
        }

        protected void SetState(Action<TState> stateMutator)
        {
            stateMutator(state);

            OnReceiveState();

            //NeedsRender?.Invoke(this);
        }

        protected void SetState(TState newState)
        {
            this.state = newState;

            OnReceiveState();

            //NeedsRender?.Invoke(this);
        }

        #endregion
        #region --- AppContext ---

        public IUserInterfaceAppContext AppContext
        {
            get => appContext;
            set
            {
                Require.ArgumentNotNull(value, nameof(AppContext));

                if (this.appContext == value)
                {
                    return;
                }

                appContext = value;

                TryFinalizeChildren();
                OnReceivedAppContext();
            }
        }

        protected virtual void OnReceivedAppContext()
        {

        }

        #endregion
        #region --- Rendering ---

        Action<IRenderable> IRenderable.NeedsRender { get => NeedsRender; set => NeedsRender = value; }
        protected Action<IRenderable> NeedsRender { get; private set; }

        public IRenderElement Parent => Display.System?.ParentOf(this);

        public virtual void DrawBackgroundAndBorder(IUserInterfaceRenderContext renderContext, Rectangle clientArea)
        {
            renderContext.UserInterfaceRenderer.DrawBackground(renderContext, Display, clientArea);
            renderContext.UserInterfaceRenderer.DrawFrame(renderContext, Display, clientArea);
        }

        public abstract void Draw(IUserInterfaceRenderContext renderContext, Rectangle clientArea);

        /// <summary>
        /// Draws the set of children.
        /// </summary>
        /// <param name="renderContext">The render context service.</param>
        /// <param name="clientArea">The client area of the element which is the parent of the children to draw.</param>
        /// <param name="children">The list of children to draw. If this is null, it will use the <c>Children</c> property.</param>
        protected void DrawChildren(IUserInterfaceRenderContext renderContext,
                                    Rectangle clientArea,
                                    IEnumerable<IRenderElement> children = null)
        {
            children = children ?? Children;

            renderContext.DrawChildren(clientArea, children);
        }

        /// <summary>
        /// Draws a single child of the current element.
        /// </summary>
        /// <param name="renderContext">The render context service.</param>
        /// <param name="clientArea">The client area of the element which is the parent of the child to draw.</param>
        /// <param name="child">The child to draw.</param>
        protected void DrawChild(IUserInterfaceRenderContext renderContext,
                                 Rectangle clientArea,
                                 IRenderElement child)
        {
            renderContext.DrawChild(clientArea, child);
        }

        #endregion
        #region --- Handling Children ---

        /// <summary>
        /// Gets or sets the children of the render element. This should only
        /// be modified by the constructor of a render element.
        /// </summary>
        public virtual IList<IRenderElement> Children { get; protected set; }

        protected virtual ChildReconciliationMode ChildReconciliationMode => ChildReconciliationMode.System;
        ChildReconciliationMode IRenderElement.ChildReconciliationMode => ChildReconciliationMode;

        protected void TryFinalizeChildren()
        {
            if (AppContext == null)
                return;

            OnFinalizeChildren();
        }

        /// <summary>
        /// Called when the render element is ready to have its children finalized.
        /// </summary>
        protected virtual void OnFinalizeChildren() { }

        /// <summary>
        /// Finalizes rendering of a set of child widgets. This must not be called in the constructor
        /// because it requires the AppContext property be set. Instead call in OnReceiveAppContext.
        /// </summary>
        /// <param name="renderables"></param>
        /// <returns></returns>
        protected IEnumerable<IRenderElement> FinalizeRendering(IEnumerable<IRenderable> renderables)
        {
            Require.That(AppContext != null, "AppContext must not be null to finalize.");

            return renderables.Where(x => x != null).Select(FinalizeRendering);
        }

        /// <summary>
        /// Finalizes rendering of a child widget. This must not be called in the constructor
        /// because it requires the AppContext property be set. Instead call in OnReceiveAppContext.
        /// </summary>
        /// <param name="renderable"></param>
        /// <returns></returns>
        protected IRenderElement FinalizeRendering(IRenderable renderable)
        {
            if (renderable == null)
                return null;

            Require.That(AppContext != null, "AppContext must not be null to finalize.");

            renderable.AppContext = AppContext;

            return renderable.FinalizeRendering(e => NeedsRender?.Invoke(e));
        }

        #endregion
        #region --- Events ---

        /// <summary>
        /// Gets the event container for the render element.
        /// </summary>
        public virtual RenderElementEvents Events { get; } = new RenderElementEvents();

        protected UserInterfaceEvent EventData { get; }

        #endregion
        #region --- Services ---

        /// <summary>
        /// Gets the display object for the render element. This contains everything the
        /// rendering system needs to display the render element.
        /// </summary>
        public RenderElementDisplay Display { get; }

        /// <summary>
        /// Gets the style of the render element. This contains things like the default font for
        /// the render element.
        /// </summary>
        public IRenderElementStyle Style => Display.Style;

        #endregion
        #region --- Identification Properties ---

        /// <summary>
        /// Gets the type identifier of this render element.
        /// </summary>
        public virtual string StyleTypeId => GetType().Name.ToLowerInvariant();

        public string StyleClass => Props.StyleClass;

        public string Name => Props.Name;

        public ElementReference Ref { get; set; }

        public override string ToString()
        {
            StringBuilder result = new StringBuilder();

            result.Append(StyleTypeId);

            if (!string.IsNullOrWhiteSpace(StyleClass))
            {
                result.Append($".{StyleClass}");
            }

            if (!string.IsNullOrWhiteSpace(Name))
            {
                result.Append($"#{Name}");
            }

            return result.ToString();
        }

        #endregion
        #region --- Focus ---

        /// <summary>
        /// Gets whether or not the render element can hold input focus.
        /// </summary>
        public virtual bool CanHaveFocus => false;

        public bool HasFocus { get; private set; }

        /// <summary>
        /// Called when the element loses focus.
        /// </summary>
        /// <remarks>
        /// If overriding this, be sure to call base.OnBlur() so HasFocus and the Props.OnFocus event get called correctly.
        /// </remarks>
        public virtual void OnBlur()
        {
            HasFocus = false;
            Props.OnBlur?.Invoke(EventData);
        }

        /// <summary>
        /// Called when the element gains focus.
        /// </summary>
        /// <remarks>
        /// When overriding OnFocus the element may choose to reject focus by returning false.
        /// If the element accepts focus, then you must make sure to call either base.OnFocus()
        /// so HasFocus and the Props.OnFocus event get called correctly, or call Display.System.SetFocus
        /// to shift the focus to a child control.
        /// </remarks>
        public virtual bool OnFocus()
        {
            HasFocus = true;
            Props.OnFocus?.Invoke(EventData);

            return true;
        }

        #endregion
        #region --- Layout ---

        /// <summary>
        /// Gets whether or not the element participates in layout.
        /// </summary>
        public virtual bool ParticipateInLayout => true;

        public virtual Size CalcMinContentSize(int? widthConstraint, int? heightConstraint)
        {
            return new Size(1, 1);
        }

        public abstract Size CalcIdealContentSize(IUserInterfaceLayoutContext layoutContext, Size maxSize);

        public abstract void DoLayout(IUserInterfaceLayoutContext layoutContext, Size size);

        protected void DoLayoutForSingleChild(IUserInterfaceLayoutContext layoutContext, Size size, IRenderElement child)
        {
            child.Display.MarginRect = new Rectangle(Point.Zero, size);

            var contentSize = child.Display.ContentRect.Size;

            child.DoLayout(layoutContext, contentSize);
        }

        /// <summary>
        /// Instructs each visible child to PerformLayout for its internals.
        /// Call this method after setting the content/margin sizes for each child.
        /// </summary>
        /// <param name="layoutContext">The layout context service.</param>
        /// <param name="children">The children to PerformLayout on. If this is null,
        /// the <c>Children</c> collection will be used.</param>
        protected void PerformLayoutForChildren(IUserInterfaceLayoutContext layoutContext, IEnumerable<IRenderElement> children = null)
        {
            children = children ?? Children;

            foreach (var item in children.Where(x => x.Display.IsVisible))
            {
                item.DoLayout(layoutContext, item.Display.ContentRect.Size);
            }
        }

        #endregion
        #region --- Updates ---

        public virtual void Update(IUserInterfaceRenderContext renderContext)
        {
            Props.OnUpdate?.Invoke(renderContext);
        }

        #endregion
        #region --- Input ---

        /// <summary>
        /// Handles a user interface action.
        /// When overriding this method, call the base method LAST to handle passing
        /// unhandled events to the parent element.
        /// </summary>
        /// <param name="args"></param>
        public virtual void OnUserInterfaceAction(UserInterfaceActionEventArgs args)
        {
            if (args.Action == UserInterfaceAction.Accept)
            {
                OnAccept(args);
            }
            else if (args.Action == UserInterfaceAction.Cancel)
            {
                OnCancel(args);
            }

            if (!args.Handled)
            {
                Parent?.OnChildAction(this, args);
            }
        }

        /// <summary>
        /// Called when a button is pressed.
        /// </summary>
        /// <param name="args"></param>
        public virtual void OnButtonDown(ButtonStateEventArgs args) { }

        /// <summary>
        /// Called when a button is released.
        /// </summary>
        /// <param name="args"></param>
        public virtual void OnButtonUp(ButtonStateEventArgs args) { }

        public virtual void OnAccept(UserInterfaceActionEventArgs args) { }

        public virtual void OnCancel(UserInterfaceActionEventArgs args) { }

        /// <summary>
        /// Event called when a child component receives an input event it can't handle.
        /// Override this method to handle that event, otherwise the event will be passed to
        /// this element's parent.
        /// </summary>
        /// <param name="child"></param>
        /// <param name="button"></param>
        public virtual void OnChildAction(IRenderElement child, UserInterfaceActionEventArgs action)
        {
            if (!action.Handled)
            {
                Parent?.OnChildAction(this, action);
            }
        }

        #endregion
        #region --- System Events ---

        IRenderable IRenderable.Render() => this;

        public virtual void OnWillUnmount()
        {
            Props.OnWillUnmount?.Invoke(EventData);
        }

        public virtual void OnDidMount()
        {
            Props.OnDidMount?.Invoke(EventData);
        }

        public virtual void OnChildrenUpdated()
        {
        }

        /// <summary>
        /// Called when props are received. If overriden, you should not
        /// modify the Children collection.
        /// </summary>
        protected virtual void OnReceiveProps()
        {
            ReceiveRenderElementProps();

            TryFinalizeChildren();
        }

        protected virtual void OnReceiveState()
        {

        }

        protected void ReceiveRenderElementProps()
        {
            Display.IsVisible = Props.Visible;

            Display.PseudoClasses.SetIf("disabled", !Props.Enabled);
        }

        public virtual void OnReconciliationCompleted()
        {
        }

        protected string FirstNotNullOrWhitespace(params string[] values)
        {
            for (int i = 0; i < values.Length; i++)
            {
                if (!string.IsNullOrWhiteSpace(values[i]))
                {
                    return values[i];
                }
            }

            return null;
        }

        void IRenderable.OnRenderResult(IRenderElement result)
        {
        }

        protected virtual void ReconcileChildren(IRenderElement other) { }
        void IRenderElement.ReconcileChildren(IRenderElement other) => ReconcileChildren(other);

        #endregion
    }

    public class RenderElementProps
    {
        private InlineElementStyle _defaultStyle;
        private InlineElementStyle _style;

        /// <summary>
        /// Gets or sets the name of the theme the styling engine should
        /// use to style the owning widget.
        /// </summary>
        public string Theme { get; set; }

        /// <summary>
        /// The ID value used in matching styles.
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// The class value used in matching styles.
        /// </summary>
        public string StyleClass { get; set; }

        /// <summary>
        /// Style elements specified by the parent. Styles specified here have the highest priority.
        /// </summary>
        public InlineElementStyle Style
        {
            get => _style;
            set
            {
                if (value != null)
                {
                    value.Specificity = 1000;
                }

                _style = value;
            }
        }

        /// <summary>
        /// The default style for this element. Styles specified here have the lowest priority.
        /// </summary>
        public InlineElementStyle DefaultStyle
        {
            get => _defaultStyle;
            set
            {
                if (value != null)
                {
                    value.Specificity = -1000;
                }

                _defaultStyle = value;
            }
        }

        /// <summary>
        /// Key which is used to match the render element during reconciliation.
        /// </summary>
        public string Key { get; set; }

        /// <summary>
        /// Event raised when a render element is mounted.
        /// </summary>
        public UserInterfaceEventHandler OnDidMount { get; set; }

        /// <summary>
        /// Event raised when a render element is unmounted.
        /// </summary>
        public UserInterfaceEventHandler OnWillUnmount { get; set; }

        /// <summary>
        /// Event raised when a render element receives the focus.
        /// </summary>
        public UserInterfaceEventHandler OnFocus { get; set; }

        /// <summary>
        /// Event raised when a render element loses the focus.
        /// </summary>
        public UserInterfaceEventHandler OnBlur { get; set; }

        /// <summary>
        /// Event raised when a render element receives its update event.
        /// </summary>
        public Action<IUserInterfaceRenderContext> OnUpdate { get; set; }

        /// <summary>
        /// Gets or sets whether the element is visible. Defaults to true.
        /// </summary>
        public bool Visible { get; set; } = true;

        /// <summary>
        /// Gets or sets whether the element is enabled for interaction
        /// with the user. Defaults to true.
        /// </summary>
        public bool Enabled { get; set; } = true;

        /// <summary>
        /// Gets or sets whether UI sounds play when the user interacts with the element or navigates
        /// within it.
        /// </summary>
        public bool PlaySounds { get; set; } = true;

        /// <summary>
        /// Used by the PropertiesEqual method to determine which properties to skip
        /// when comparing.
        /// </summary>
        /// <param name="propertyName"></param>
        /// <returns></returns>
        protected virtual bool CanDoValueComparison(PropertyInfo property)
        {
            return property.Name != "Children";
        }

        /// <summary>
        /// Compares two props objects to see if their property values are equal.
        /// By default, this uses reflection to check each individual property, except
        /// properties named "Children".
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        public virtual bool PropertiesEqual(RenderElementProps other)
        {
            if (other.GetType() != GetType())
            {
                return false;
            }

            PropertyInfo[] properties = GetType().GetProperties();

            foreach (PropertyInfo prop in properties.Where(x => CanDoValueComparison(x)))
            {
                object myValue = prop.GetValue(this);
                object otherValue = prop.GetValue(other);

                if (myValue == null && otherValue == null)
                {
                    continue;
                }

                if (myValue == null || otherValue == null)
                {
                    return false;
                }

                if (!myValue.Equals(otherValue))
                {
                    return false;
                }
            }

            return true;
        }
    }

    [Obsolete("This class does nothing, references to it are useless.", true)]
    public class RenderElementState
    {

    }

    public static class RenderElementExtensions
    {
        /// <summary>
        /// Compute the ideal size of an element's margin rectangle.
        /// </summary>
        /// <param name="element"></param>
        /// <param name="layoutContext"></param>
        /// <param name="maxSize"></param>
        /// <returns></returns>
        public static Size CalcIdealMarginSize(this IRenderElement element,
                                               IUserInterfaceLayoutContext layoutContext,
                                               Size maxSize)
        {
            var contentSize = element.CalcIdealContentSize(layoutContext, maxSize);

            var marginSize = element.Display.Region.MarginToContentOffset.Expand(contentSize);

            return marginSize;
        }

        /// <summary>
        /// Computes the minimum size of an element's margin rectangle.
        /// </summary>
        /// <param name="element"></param>
        /// <param name="widthConstraint"></param>
        /// <param name="heightConstraint"></param>
        /// <returns></returns>
        public static Size CalcMinMarginSize(this IRenderElement element,
                                             int? widthConstraint,
                                             int? heightConstraint)
        {
            var contentSize = element.CalcMinContentSize(widthConstraint, heightConstraint);

            var marginSize = element.Display.Region.MarginToContentOffset.Expand(contentSize);

            return marginSize;
        }

        /// <summary>
        /// Copies standard WidgetProps members to the RenderElementProps structure.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="elementProps"></param>
        /// <param name="props"></param>
        /// <returns></returns>
        public static T CopyFromWidgetProps<T>(this T elementProps, WidgetProps props, bool overwriteExisting = true)
            where T : RenderElementProps
        {
            if (overwriteExisting)
            {
                elementProps.Key = props.Key ?? elementProps.Key;
                elementProps.Name = props.Name ?? elementProps.Name;
                elementProps.Theme = props.Theme ?? elementProps.Theme;
                elementProps.Style = props.Style ?? elementProps.Style;
                elementProps.StyleClass = props.StyleClass ?? elementProps.StyleClass;
                elementProps.DefaultStyle = props.DefaultStyle ?? elementProps.DefaultStyle;
                elementProps.Visible = props.Visible;
                elementProps.PlaySounds = props.PlaySounds;
            }
            else
            {
                elementProps.Key = props.Key ?? elementProps.Key;
                elementProps.Name = elementProps.Name ?? props.Name;
                elementProps.Theme = elementProps.Theme ?? props.Theme;
                elementProps.Style = elementProps.Style ?? props.Style;
                elementProps.StyleClass = elementProps.StyleClass ?? props.StyleClass;
                elementProps.DefaultStyle = elementProps.DefaultStyle ?? props.DefaultStyle;
                // Not overwriting value for Visible.
            }

            return elementProps;
        }
    }
}

redpajama_set_name: RedPajamaGithub


Quality Education has always been the prime focus of Hajvery University. HU Management ensures quality in every dimension and manner whether it is to provide infrastructure and ancillary facilities to students or to develop intellect in them. Even before the launch of HEC-QAA, HU has been practicing measures, which were already as per HEC requirement, to attain the target of producing 21st century human resource. To ensure quality of education at Hajvery University as per HEC directives, HU QEC was established on June 19, 2010 with the following Mission Statement and Objectives.
Hajvery University resolves to guarantee its stakeholders that the quality of the university education be maintained and enhanced as per international standards, and procedures and protocols are regularly checked for transparency and objectivity in order to achieve quality enhancement.
To maintain standards of teaching and research in each subject area.
To develop qualification frameworks and program specifications to determine what knowledge, understanding, skills and other attributes a student will have developed on successfully completing a specific program.
To develop quality assurance processes and methods of evaluation to affirm that standards of awards are being maintained.
To promote curriculum, subject and staff development together with research and other scholarly activities.
To develop procedures for the monitoring and evaluation of programs, faculty and students' perception.


text:
///<reference path="../reference.ts" />

module Plottable {
export module Plots {
  export class Area<X> extends Line<X> {
    private static _Y0_KEY = "y0";
    private _lineDrawers: Utils.Map<Dataset, Drawers.Line>;
    private _constantBaselineValueProvider: () => number[];

    /**
     * An Area Plot draws a filled region (area) between Y and Y0.
     *
     * @constructor
     */
    constructor() {
      super();
      this.addClass("area-plot");
      this.y0(0); // default
      this.attr("fill-opacity", 0.25);
      this.attr("fill", new Scales.Color().range()[0]);

      this._lineDrawers = new Utils.Map<Dataset, Drawers.Line>();
    }

    protected _setup() {
      super._setup();
      this._lineDrawers.forEach((d) => d.renderArea(this._renderArea.append("g")));
    }

    public y(): Plots.AccessorScaleBinding<number, number>;
    public y(y: number | Accessor<number>): Area<X>;
    public y(y: number | Accessor<number>, yScale: QuantitativeScale<number>): Area<X>;
    public y(y?: number | Accessor<number>, yScale?: QuantitativeScale<number>): any {
      if (y == null) {
        return super.y();
      }

      if (yScale == null) {
        super.y(y);
      } else {
        super.y(y, yScale);
      }

      if (yScale != null) {
        let y0 = this.y0().accessor;
        if (y0 != null) {
          this._bindProperty(Area._Y0_KEY, y0, yScale);
        }
        this._updateYScale();
      }
      return this;
    }

    /**
     * Gets the AccessorScaleBinding for Y0.
     */
    public y0(): Plots.AccessorScaleBinding<number, number>;
    /**
     * Sets Y0 to a constant number or the result of an Accessor<number>.
     * If a Scale has been set for Y, it will also be used to scale Y0.
     *
     * @param {number|Accessor<number>} y0
     * @returns {Area} The calling Area Plot.
     */
    public y0(y0: number | Accessor<number>): Area<X>;
    public y0(y0?: number | Accessor<number>): any {
      if (y0 == null) {
        return this._propertyBindings.get(Area._Y0_KEY);
      }
      let yBinding = this.y();
      let yScale = yBinding && yBinding.scale;
      this._bindProperty(Area._Y0_KEY, y0, yScale);
      this._updateYScale();
      this.render();
      return this;
    }

    protected _onDatasetUpdate() {
      super._onDatasetUpdate();
      this._updateYScale();
    }

    public addDataset(dataset: Dataset) {
      let lineDrawer = new Drawers.Line(dataset);
      if (this._isSetup) {
        lineDrawer.renderArea(this._renderArea.append("g"));
      }
      this._lineDrawers.set(dataset, lineDrawer);
      super.addDataset(dataset);
      return this;
    }

    protected _removeDatasetNodes(dataset: Dataset) {
      super._removeDatasetNodes(dataset);
      this._lineDrawers.get(dataset).remove();
    }

    protected _additionalPaint() {
      let drawSteps = this._generateLineDrawSteps();
      let dataToDraw = this._getDataToDraw();
      this.datasets().forEach((dataset) => this._lineDrawers.get(dataset).draw(dataToDraw.get(dataset), drawSteps));
    }

    private _generateLineDrawSteps() {
      let drawSteps: Drawers.DrawStep[] = [];
      if (this._animateOnNextRender()) {
        let attrToProjector = this._generateLineAttrToProjector();
        attrToProjector["d"] = this._constructLineProjector(Plot._scaledAccessor(this.x()), this._getResetYFunction());
        drawSteps.push({attrToProjector: attrToProjector, animator: this._getAnimator(Plots.Animator.RESET)});
      }
      drawSteps.push({attrToProjector: this._generateLineAttrToProjector(), animator: this._getAnimator(Plots.Animator.MAIN)});
      return drawSteps;
    }

    private _generateLineAttrToProjector() {
      let lineAttrToProjector = this._generateAttrToProjector();
      lineAttrToProjector["d"] = this._constructLineProjector(Plot._scaledAccessor(this.x()), Plot._scaledAccessor(this.y()));
      return lineAttrToProjector;
    }

    protected _createDrawer(dataset: Dataset) {
      return new Plottable.Drawers.Area(dataset);
    }

    protected _generateDrawSteps(): Drawers.DrawStep[] {
      let drawSteps: Drawers.DrawStep[] = [];
      if (this._animateOnNextRender()) {
        let attrToProjector = this._generateAttrToProjector();
        attrToProjector["d"] = this._constructAreaProjector(Plot._scaledAccessor(this.x()),
                                                            this._getResetYFunction(),
                                                            Plot._scaledAccessor(this.y0()));
        drawSteps.push({attrToProjector: attrToProjector, animator: this._getAnimator(Plots.Animator.RESET)});
      }

      drawSteps.push({attrToProjector: this._generateAttrToProjector(), animator: this._getAnimator(Plots.Animator.MAIN)});

      return drawSteps;
    }

    protected _updateYScale() {
      let extents = this._propertyExtents.get("y0");
      let extent = Utils.Array.flatten<number>(extents);
      let uniqExtentVals = Utils.Array.uniq<number>(extent);
      let constantBaseline = uniqExtentVals.length === 1 ? uniqExtentVals[0] : null;

      let yBinding = this.y();
      let yScale = <QuantitativeScale<number>> (yBinding && yBinding.scale);
      if (yScale == null) {
        return;
      }

      if (this._constantBaselineValueProvider != null) {
        yScale.removePaddingExceptionsProvider(this._constantBaselineValueProvider);
        this._constantBaselineValueProvider = null;
      }

      if (constantBaseline != null) {
        this._constantBaselineValueProvider = () => [constantBaseline];
        yScale.addPaddingExceptionsProvider(this._constantBaselineValueProvider);
      }
    }

    protected _getResetYFunction() {
      return Plot._scaledAccessor(this.y0());
    }

    protected _propertyProjectors(): AttributeToProjector {
      let propertyToProjectors = super._propertyProjectors();
      propertyToProjectors["d"] = this._constructAreaProjector(Plot._scaledAccessor(this.x()),
                                                               Plot._scaledAccessor(this.y()),
                                                               Plot._scaledAccessor(this.y0()));
      return propertyToProjectors;
    }

    public selections(datasets = this.datasets()) {
      let allSelections = super.selections(datasets)[0];
      let lineDrawers = datasets.map((dataset) => this._lineDrawers.get(dataset))
                                .filter((drawer) => drawer != null);
      lineDrawers.forEach((ld, i) => allSelections.push(ld.selectionForIndex(i).node()));
      return d3.selectAll(allSelections);
    }

    protected _constructAreaProjector(xProjector: Projector, yProjector: Projector, y0Projector: Projector) {
      let definedProjector = (d: any, i: number, dataset: Dataset) => {
        let positionX = Plot._scaledAccessor(this.x())(d, i, dataset);
        let positionY = Plot._scaledAccessor(this.y())(d, i, dataset);
        return Utils.Math.isValidNumber(positionX) && Utils.Math.isValidNumber(positionY);
      };
      return (datum: any[], index: number, dataset: Dataset) => {
        let areaGenerator = d3.svg.area()
                                  .x((innerDatum, innerIndex) => xProjector(innerDatum, innerIndex, dataset))
                                  .y1((innerDatum, innerIndex) => yProjector(innerDatum, innerIndex, dataset))
                                  .y0((innerDatum, innerIndex) => y0Projector(innerDatum, innerIndex, dataset))
                                  .interpolate(this.interpolator())
                                  .defined((innerDatum, innerIndex) => definedProjector(innerDatum, innerIndex, dataset));
        return areaGenerator(datum);
      };
    }
  }
}
}


The only constant is change. To keep pace with constant change, Xerox provides simple solutions for a complex world. We remain true to our heritage by solving business problems with diverse services, innovative technologies and the expertise of Xerox people.
We thrive on finding new ideas that solve our customers' real business challenges..
We value and empower employees.


Ameriwood 5 shelf bookcase multiple finishes, mainstays 5 shelf bookcase instructions for pictures, mainstays 5 shelf bookcase instructions for pictures. Bookcase instructions good 23 inch wide bookcase 24 on. Mainstays 5 shelf bookcase instructions for pictures.


The service provider has developed website template and e-commerce portal software that is used to provide the template to the client.
The client wishes to appoint the service provider who in turn wishes to host software on its systems. The main idea is to access such software together with other services on the following terms and conditions.
"Business Day" is not a Saturday, a Sunday or a public holiday in England or Wales.
"Client" means the individual or company entering into our terms and conditions. "Client Software" means any designs, artwork, logos or information supplied by the client in connection with the software.
"Confidential Information" means information concerning the finances, business, solutions, technology or commercial affairs which is described as confidential.
"Documentation" means the user manuals supplied by the service provider and other modifications supplied to the client during the agreement.
"Effective Date" is the date the client uploads the content and provides the materials.
"Fees" means the amount paid by the client to the service provider for the website.
"Intellectual property rights" are the trademarks, service marks, internet domain names and registered designs or any other similar protected rights in any country now or in the future.
"IP Address" means the internet protocol address that is the numeric address of the server.
"Services" means the detailed services of the provider of the client contracts.
"Service hours" are the hours between midnight and 6 am GMT or other seasonal variation as is applicable in the UK.
"Service Provider" means Zuxx Limited.
"Service Provider's Website" means the website located at the URL.
"Website" means the website of the client developed by the temple of the service provider and hosted as part of their services.
There are references of several clauses in this agreement like headings and these are for convenience. They are not intended to affect the agreement.
Hosting and supporting the software in clauses mentioned below.
The provider also reserves the right to modify the software including, but not limited to the functionality of the software from time to time for enhancing the performance of the software.
The service provider should also maintain control and ownership of the IP address assigned to the client as part of the services. He also reserves the right in sole discretion for changing the IP address.
Where the service provider removes the IP address, it should not cause any disruption to the client.
The client also agrees that the employees keep identification information issued by the service provider as confidential in accordance with the previous clauses. The client will be responsible for any unauthorized use of personal identification information. The client will also notify the service provider immediately.
The client may not lease, loan or distribute the access to the software by any third party.
The client represents that it shall maintain security measures without limitation, authenticity, confidentiality to ensure access to the software granted under the agreement.
The service provider also does not set limits on the usage of the bandwidth, but operates a fair usage policy.
The service provider shall use reasonable endeavours ensuring that during the term of the agreement, the access to client's software is hosted by the service providers, subject to repairs and routine maintenance.
The service provider should not have any liability to the client in respect to the inability of access to the software or errors in the functioning of the same.
The service provider is liable to use reasonable endeavours for ensuring that the term of the agreement is accessible by the client. They should function effectively with emergency maintenance, repairs and configurations.
On opening an account, the client will have to nominate a primary support contact. The account details along with the primary support contact can be amended by the client anytime. The service provider will not be under any obligation to respond or support the queries by the representatives other than the ones nominated by the client.
The service provider will acknowledge the receipt of any problem through the support telephone number and email address. They will take into account the severity of the problem and make actions to correct the problem promptly.
If the service provider opined that the problem cannot be resolved, the client is notified of the failure.
The service provider should be entitled to suspend the access to the services on notice to the client for the period required for maintenance or improvements.
Client is liable to provide the service with any client material essential by the service provider in the format the providers require.
The alterations and updates in the websites will be made by the client with online account management facility. The client will get a user name and password to access to the accountant pursuant.
The client also agrees to cooperate with the service provider by making it available to the employees and staffs.
The client shall obtain all the expenses before supplying any material to the service provider including approvals, authorisation, licenses and consents.
The client will be responsible for the transmission of any data. Such data might even contain personal data, and the client warrants with the obligations under the act. He shall also keep indemnified service provider against any damage, losses or expenses suffered by the service provider due to breach of contract.
The service provider will also carry legal proceedings for transmission of personal data only to the extent necessary for the provision of the services.
The service provider will also ensure that it makes use of appropriate security measure for safeguarding against any unauthorized access or unlawful proceedings of personal data.
The client acknowledges the rights of intellectual property in the software and the temple and it should be the property of the service provider. The client will not obtain any rights in the software other than the one granted under the agreement.
The service provider also grants the clients and the employees a royalty free, non-exclusive of license in an object code form. The agreement does not transfer or grant to the client the interest or title in the software.
The service provider should maintain control and ownership of the IP address that is assigned to the client as part of the services.
If the service provider changes or removes any IP address, it shall have reasonable endeavours for avoiding disruption.
Subject to the proper observance and the obligations, the service provider at his own expense shall defend or settle any claims for the third party. He agrees to be responsible for any reasonable costs awarded against the client.
If a claim is made against the client, the client shall notify the service provider immediately.
At the request and expense of the service provider, the client shall also offer reasonable assistance for contesting any claim.
The client shall also not make any admission in lieu of settling to any claim.
If a claim is made in reasonable opinion of the service provider, it should at the own expense.
If the service provider has availed the rights of modifying the software for procuring license and avoids the claim, the provider shall not have any liability in respect to the claims.
The clients shall hold harmless against the service provider with any claims, actions or losses.
The client shall pay fees monthly in advance and will receive notification by email. If there is a fee increment, the client shall give a written notice. All amounts are gross amounts and exclusive of VAT or other sales tax and it should be paid by the client.
Each party must maintain strict confidentiality in any information received directly or indirectly. The information shall not be disclosed to any third party other than the employees and authorized people.
The terms and conditions of the entire agreement between the parties in relation to the subject matter, conditions, statement and warranties will apply. The parties will acknowledge that by entering into the agreement, they do not rely on representation, unless fraud or other provision. Any variation to the agreement must be expressed in writing and signed by both the parties. Nothing in the agreement shall be governed by and constructed with the Laws of England and Wales. The parties hereby should submit to the non-exclusive jurisdiction.


text:
Engine of the Week
Engine of the Year Contest
Diesel of the Week
Diesel of the Year Contest
Content for engine professionals and enthusiasts
Are Water Injection Systems Coming Back to Production Cars?
The idea of injecting water into the combustion chamber of an engine has been around since the 1940s and has been weaving in and out of cars since the 1960s, but never caught on. However, BMW recently announced that its upcoming M4 GTS would be marketed with a water injection system. This development now presents the question of whether or not the technology will finally become widespread in the performance segment.
By Sterling Shriber
- LS Intake Manifolds
- LS Cylinder Heads
- Choosing the Correct Block for Your LS Engine Build
The idea of injecting water into the combustion chamber of an engine has been around since the 1940s when it was first employed in aircraft engines. While weaving in and out of cars since the 1960s, the technology has never really caught on. However, BMW recently announced that they would be marketing their upcoming M4 GTS, due to arrive this summer, with a water injection system. This development now presents the question of whether or not the technology will finally become widespread in the performance segment.
Also known as anti-detonant injection, this technology first appeared in 1962 on the Oldsmobile 215 Turbo Jetfire engine. The Turbo Jetfire was an early turbocharged design that sprayed distilled water and methanol into the combustion chamber. Chrysler also experimented with the technology in the early 1960s, and the Saab 99 Turbo offered water injection during the 1970s. Water injection was consequential on early turbocharged cars, used to keep combustion chamber temperatures lower. However, once the development of the modern day intercooler accelerated, water injection systems seemingly went on the wane.
In today's day and age, despite the claims that water injection systems are rendered unnecessary on forced induction engines, the technology still introduces a cadre of fundamental benefits, perhaps the reason why BMW is investing in it.
The benefits of a water injection system stem from the ability of water to absorb heat in the combustion chamber and reduce temperatures. This has the obvious effect of reducing pre-ignition and detonation of fuel and thereby preventing knocking. In modern day applications, this may be used to support a higher compression ratio, for more power and greater efficiency- an adjustment usually not allowed due to the threat of detonation.
Higher levels of boost can also be reaped from forced induction engines due to the reduced probably of detonation after water injection; water cooling of the ambient intake air may allow for greater density and therefore more air content to be packed into the cylinder.
Water injection can also be used to reduce the overall thermal load on a high-performing engine by cooling engine components normally exposed to massive amounts of heat, in addition to ambient air inside the combustion chamber. Exhaust gas temperatures have also been consistently shown to be lower on water injection engines, due to lower initial intake and combustion temperatures. However, exhaust gas temperatures do increase noticeably as more methanol, which is commonly coupled with water in such systems, is added.
Common in aftermarket settings, the technology is used on high performing engines, and several companies offer water injection systems for aftermarket sale. Many use these systems to reduce the need for an intercooler or to be able to run smaller intercoolers on their engines, in the interest of lessening pressure drop through the intercooler system and eliminating resultant turbo lag; though it currently remains a subject of debate as to whether or not this is the best course of action.
Methanol injection is also commonly used in conjunction with water injection. In fact, most of the aforementioned systems being marketed today are 50/50 water-methanol injection systems. The presence of methanol effectively increases the octane rating of the delivered fuel/air mixture, affording better protection against detonation and more power. Oils have also been delivered with the water-methanol mixture, in an effort to protect metal components against corrosion resultant from the water inflow.
While water injection has been mildly popular in the aftermarket scene for some time, BMW is the first major automaker committing to bringing such a system to market in recent memory. Their water injection system first appeared earlier this year on the company's Moto GP safety car(shown below,) which was a modified M4 variant. The company, however, announced to Car and Driver that they would be bringing a water injection system to their new M4 GTS, which will make its debut this summer at the 2015 Pebble Beach Concours d'Elegance and likely go on sale in the fall.
BMW commented that the design allowed for greater fuel efficiency, likely from an enlarged compression ratio, and they also highlighted the ability of the engine to run on lower octane fuels, resultant from the reduced probability of detonation.
The upcoming M4 GTS' twin-turbo straight six is known to be fed by a 1.5 gallon water tank controlled by an electronic water pump and mounted in the trunk. The tank will need to be refilled approximately every five fuel stops. Naturally, the M4 GTS is a higher end performance model, and water injection systems offered by BMW will likely remain constrained to such; don't expect your average BMW driver to be enthused about filling a water tank every five fuel stops.
In contrast to many water injection designs, the BMW system may use direct or port injection to deliver water, though this can increase production costs substantially if new cylinder head or intake port designs are required as a result; most aftermarket system inject water just upstream of the intake manifold. It also remains unknown whether or not the BMW system makes use of methanol or other additives, as well as what type of water the tank necessitates being refilled with. The concern of added weight by virtue of the system, as well as energetic costs necessary to run the water pump, also raise significant questions which are presently unanswered.
Whether or not BMW will keep water injection technology around for the foreseeable future remains to be seen. However, the fact that the technology is being revisited by a major automaker is of interest.
Does anyone have experience with water injection systems? Drop us a comment below. More information specific to aftermarket water-methanol injection systems can be found at Engine Builder Magazine.
Tags: Combustion Engine, engine
Open Loop/Closed Loop and Learning
Shop Solutions January 2023
Shop Solutions December 2022
Jesel Certified Performance Rebuilds
Top 10 Ken Block Gymkhana Films
UNDERSTANDING OIL CLEARANCES IN ENGINE BEARINGS
Sponsored By King Engine Bearings
Going the Extra Mile with Cylinder Head Porting
It's not just the port work alone that creates spectacular cylinder head performance. The most critical areas of a cylinder head are those which pass the most air at the highest speed and for the longest duration. Your bowl area, the valve job, the throat diameter, and combustion chamber are all crucial parts.
By Greg Jones
Every engine builder is after the ultimate in performance gains. When it comes to cylinder head performance, we're all trying to maximize airflow to create more power. In order to accomplish that, builders have to know what to manipulate in order to make improvements. Those improvements to airflow quality and quantity come from porting and removing areas of restriction.
More Tech Center Posts
Tight Tolerances and Building Power
As you ascend Mt. Everest, you reach an area called the death zone. Once you climb high enough, the margin of error becomes perilously thin. That death zone also applies to engines. As the horsepower per cubic inch and rpm increase, the margin of error decreases.
By Lake Speed, Jr. Nov 17, 2022
CNC Update: Features and Automation
Precision is key when it comes to automotive parts; the complex designs of connecting rods, pistons and rings, blocks, cylinder heads, and other parts require super tight tolerances that are getting more and more difficult to be met by hand or with other machining processes outside of CNC.
By Evan Laux Nov 17, 2022
All Things Media Blasting
Engine building is a segment of the automotive industry that has always been ahead of the curve in media blasting, and no matter the engine shop, cleaning equipment is a common bond.
By Eric Garbe Nov 17, 2022
Engine & Hub Dynos: Necessary Tools and Additional Revenue
Being able to see the horsepower and the direct correlation to what is lost in the driveline is invaluable – dynos offer a myriad of benefits for the modern engine shop.
By Greg Jones Nov 17, 2022
November 2022 Shop Solutions
November tricks and tips for the shop!
By Engine Builder Nov 16, 2022
Shop Solutions October 2022
When machining on the CNC mill, it's necessary to blow the flood coolant and chips off the parts for inspection. I tried a tool holder mounted fan, but it wouldn't get all the chips and coolant out of the deeper areas.
By Shop Solutions – The Power of Knowledge Oct 20, 2022
Could Engine Oil Soon Contain No Oil?
The trend towards ever thinner engine oils is an effort to reduce fuel consumption and emissions. How far can it go?
By Engine Builder Oct 11, 2022
Building Big Block Marine Engines
Find out what it takes to build a formidable marine engine.
By Engine Builder Sep 27, 2022
Benefits of Water/Methanol Injection
Radial Motion's 3-Cylinder Compact Radial Engine
Continental VDO OEM Electric Water Pump for BMW Range


text:
FONT SIZE: PRINT:
TED HOME
ARCHIVE BY PROGRAM
Occupations projected to add most new jobs, 2012 to 2022
The 30 occupations that are projected to add the most new jobs by 2022 are expected to account for almost half of all new jobs. Over the 2012 to 2022 period, personal care aides is projected to add 580,800 new jobs, more than any other occupation, corresponding to a growth rate of 48.8 percent.
Chart Image
Chart Data
Change in employment and projected 2022 employment for occupations with the largest numeric projected growth in jobs, 2012 to 2022
Projected change, 2012–2022
Projected employment in 2022
Employment (number of jobs)
Total, all occupations(1)
15,628,000 10.80% 160,983,700
580,800 48.8 1,771,400
434,700 9.8 4,881,700
189,200 36.0 714,900
(1) Total includes occupations not shown.
Of the 30 occupations projected to experience the largest employment increases, 5 are in healthcare. Combined, these 5 occupations are projected to add 1.6 million jobs over the 2012–2022 decade. The number of registered nurses is projected to grow by 526,800 (or 19.4 percent), while the number of home health aides is expected to increase by 424,200 (48.5 percent).
The 7 office and administrative support occupations listed in the table of 30 occupations projected to experience the largest employment increases are projected to account for 1.5 million new jobs. This large numeric growth reflects the large size of most of these occupations. The number of secretaries and administrative assistants, except legal, medical, and executive is expected to grow from 2,324,400 to 2,632,300 over the 2012–2022 period, an increase of 307,800 (or 13.2 percent).
Two-thirds of the occupations projected to add the most new jobs typically require a high school diploma or less, while only five typically require a bachelor's degree.
These data are from the BLS Employment Projections program. For more information, see the Monthly Labor Review article, "Occupational employment projections to 2022," by Emily Richards and Dave Terkanian, December 2013. Additional information about these and many other occupations may be found in the Occupational Outlook Handbook. Note that the chart does not show all 30 of the occupations projected to add the most new jobs by 2022. However, all 30 are listed on the accompanying table.
Occupational employment projections to 2022
Bureau of Labor Statistics, U.S. Department of Labor, The Economics Daily, Occupations projected to add most new jobs, 2012 to 2022 on the Internet at https://www.bls.gov/opub/ted/2014/ted_20140127.htm (visited July 18, 2019).
Recent editions of Spotlight on Statistics
25 years of Worker Injury, Illness, and Fatality Case Data
Examines detailed historical data on work-related injuries, illnesses, and fatal injuries.
Occupational employment projections through the perspective of education and training
Examines employment, projected employment growth, and wages for occupations with different education and training requirements.
Workers in Alternative Employment Arrangements
A look at independent contractors, on-call workers, temporary help agency workers, and workers provided by contract firms.
Labor force characteristics of people with a disability
Examines the labor force characteristics of people with a disability and compares them with the characteristics of people with no disability.
Quicklinks Footer
U.S. Bureau of Labor Statistics | Postal Square Building, 2 Massachusetts Avenue, NE Washington, DC 20212-0001
www.bls.gov | Telephone: 1-202-691-5200 | Federal Relay Service: 1-800-877-8339 | Contact Us


Warner, They Went to the Video Tape and Your Busted!
Sports broadcasting legend Warner Wolf — who coined the phrase, "Let's go to the videotape" — was arrested in Florida after officials say he ripped the word, "Plantation," off a sign at a private community. Long story short … Wolf lives in a gated community called "Classics Plantation Estates" in Naples, Florida (about 60 miles from Miami) … but he thinks the word, "plantation," is offensive and wanted it removed. According to the police report, Wolf had lobbied the homeowners association to drop it for months — but on Nov. 30, the 81-year-old finally took matters into his own hands. Cops say Warner drove to the main community sign — located in a fancy fountain — and used a tool to remove the word himself. Officials say they have video showing Wolf defacing the sign — and after a lengthy investigation, he finally surrendered to police on Feb. 7. Also, cops say Warner returned the letters from the sign to the community security guard.


The 2015 Legislative Session is rapidly drawing to a close. The budget conferees have agreed on a budget and have issued a conference report. The full Assembly is expected to vote on the conference report today and the assumption is that it will be approved. From our perspective, a quick recap of the overall results would be "good news, bad news".
First, the bad news. The House Appropriations Subcommittee on Compensation and Retirement once again tabled our VaLORS bill – SB 692.
Now, the good news. And, the good news is pretty spectacular. This was one of our best years in a long time in terms of state park system dollars.
As you know, the Governor included $2.24 million in his budget for initial development of Seven Bends State Park . This provision was retained in the conference report.
$177,000 to acquire land in-holdings at Natural Tunnel State Park .
$2.5 million for the future Clinch River State Park as part of an overall $14 million planning pool for future projects in multiple budget areas.
Thank you for your input to legislative members supporting the state park system needs. Without your inputs, the successes outlined above would not have been possible!
Please be assured that your continuing support for Virginia 's parks is greatly appreciated!


text:
IRS Hits Business Owner with $4.3 Million Trust Fund Penalty for Business's Unpaid Payroll Taxes—Federal Court Upholds Assessment
Jason B. Freeman
jason@freemanlaw.com
Mr. Freeman is the founding member of Freeman Law, PLLC. He is a dual-credentialed attorney-CPA, author, law professor, and trial attorney.
Mr. Freeman has been named by Chambers & Partners as among the leading tax and litigation attorneys in the United States and to U.S. News and World Report's Best Lawyers in America list. He is a former recipient of the American Bar Association's "On the Rise – Top 40 Young Lawyers" in America award. Mr. Freeman was named the "Leading Tax Controversy Litigation Attorney of the Year" for the State of Texas for 2019 and 2020 by AI.
Mr. Freeman has been recognized multiple times by D Magazine , a D Magazine Partner service, as one of the Best Lawyers in Dallas, and as a Super Lawyer by Super Lawyers, a Thomson Reuters service. He has previously been recognized by Super Lawyers as a Top 100 Up-And-Coming Attorney in Texas.
Mr. Freeman currently serves as the chairman of the Texas Society of CPAs (TXCPA). He is a former chairman of the Dallas Society of CPAs (TXCPA-Dallas). Mr. Freeman also served multiple terms as the President of the North Texas chapter of the American Academy of Attorney-CPAs. He has been previously recognized as the Young CPA of the Year in the State of Texas (an award given to only one CPA in the state of Texas under 40).
A recent ruling by a federal Texas district court serves as yet another reminder of the exposure that business owners face when it comes to personal liability for the unmet payroll taxes of their businesses. In McClendon v. United States, the district court recently held a doctor-taxpayer/business owner personally responsible for $4.3 million of the business's outstanding payroll taxes, upholding the IRS's prior trust fund tax assessment. The assessment of the penalty was largely based upon the doctor's personal loans made to the business in order to allow it to make payroll after he learned of the business's outstanding liabilities.
The facts of the case are straightforward: The doctor-taxpayer, Dr. McClendon, owned and operated Family Practice, a medical-services provider. By the year 2009, Family Practice owed the IRS more than $10 million in unpaid payroll and withholding taxes—a fact that Dr. McClendon did not learn until later in 2009. The company's former CFO had pleaded guilty for embezzling substantial funds from Family Practice. His embezzlement and cover up was apparently related to the mounting outstanding taxes. With the business facing substantial outstanding payroll taxes, Dr. McClendon made a substantial personal loan to Family Practice "for the restricted purpose of … using the funds to pay the May 15, 2009 payroll." The business used that loan to pay its employees.
The Trust Fund Penalty: The Internal Revenue Code requires employers to withhold their employees' share of federal social security and income taxes from the employees' wages. 26 U.S.C. §§ 3102 and 3402. The employer holds these funds "in trust" for the United States; they are thus referred to as "trust fund" taxes. 26 U.S.C. § 7501(a). To ensure that the taxes are remitted to the government, 26 U.S.C. § 6672(a) imposes a penalty equal to the entire amount of any such unpaid "trust fund" taxes against any "responsible person":
Any person required to collect, truthfully account for, and pay over any tax imposed by this title who willfully fails to collect such tax, or truthfully account for and pay over such tax, or willfully attempts in any manner to evade or defeat any such tax or the payment thereof, shall, in addition to other penalties provided by law, be liable to a penalty equal to the total amount of the tax evaded, or not collected, or not accounted for and paid over ….
Thus, liability for the penalty is established if a person is a "responsible person" who "willfully" failed to pay over the withheld taxes. Turnbull v. United States, 929 F.2d 173, 178 (5th Cir. 1991). Notably, the IRS takes the position that a responsible person can be an owner, director, officer, employee, creditor, bookkeeper or any other person who has a sufficient relationship to the business and/or the payment of its taxes to give rise to such status.
In McClendon, the taxpayer conceded his responsible person status; the only issue was whether he willfully failed to collect, account for, or pay taxes that Family Practice owed to the IRS.
A major issue in the case was the doctor's personal loan and the business's use of those funds to make payroll (but not to pay the outstanding trust fund taxes). Under the law, the IRS takes the position that a responsible person has a duty to ensure that a taxpayer's unencumbered funds are used to pay back taxes it owes the IRS, rather than to pay other creditors. The government contends that "[a] considered decision not to fulfill one's obligation to pay the taxes owed, evidenced by payments made to other creditors in the knowledge that the taxes are due, is all that is required" to invoke the trust fund penalty. Mazo v. United States, 591 F.2d 1151, 1155 (5th Cir. 1979). The government further contends that the payment of wages to employees constitutes a payment to a creditor for purposes of this principle. Logal v. United States, 195 F.3d 229, 232 (5th Cir. 1999). In other words, it is the government's position that "[i]f a responsible person knows that withholding taxes are delinquent, and uses corporate funds to pay other expenses, even to meet the payroll out of personal funds he lends the corporation," that person has acted willfully within the meaning of the statute. Phillips v. U.S. I.R.S., 73 F.3d 939, 942 (9th Cir. 1996) (emphasis added).
It was against this background law and reasoning that the IRS assessed the trust fund recovery penalty at issue in McClendon. The court, accepting the IRS's arguments, granted summary judgment against the taxpayer, finding him liable for the trust fund penalty. A snippet of its relevant analysis follows:
[T]he undisputed facts show that, as a matter of law, Dr. McClendon acted willfully. After Dr. McClendon knew that Family Practice owed back taxes, he loaned Family Practice money to make payroll. Family Practice used that money to pay its current payroll obligation to its employees rather than to pay the taxes it owed.
Dr. McClendon testified that his purpose in lending the money was to provide money that Family Practice could use to pay certain creditors (its employees) on a preferential basis, rather than paying the government. (Docket Entry No. 24-3, Ex. 2 at 7). The funds were not "encumbered" in the relevant sense, and Dr. McClendon's argument [in defense] fails.
In other words, the court rejected the taxpayer's argument that his personal loans to the business constituted "encumbered" funds—making it legally impossible for him, as a responsible person, to use the funds to pay the outstanding tax liabilities. The taxpayer sought to invoke a narrow exception to trust fund penalty liability that applies where a taxpayer is legally obligated to use the funds for some other purpose than satisfying preexisting employment tax liabilities, and where that legal obligation is superior to the interest of the IRS in the funds. This encumbered-funds defense derives directly from the definition of willfulness—if the taxpayer is legally obligated to use the funds for some other purpose, then they are not available to pay the outstanding tax liability, and, so the argument goes, the taxpayer cannot be said to have voluntarily chosen to prefer another creditor over the IRS. But as McClendon demonstrates, courts have interpreted this defense quite narrowly.
For other posts on the Trust Fund Penalty and employment taxes, see:
Employment Tax Enforcement is on the Rise
The Crime of Willfully Failing to Collect or Pay Over Tax
Another Trust Fund-Related Tax Indictment
Probate Trust and Fiduciary Litigation Lawyers
Need assistance managing probate proceedings, will contests, trust, and fiduciary litigation, or disputes involving the administration of estates and trusts. Freeman Law represents executors, administrators, trustees, beneficiaries, and heirs. Our Firm offers a unique blend of legal skills and an accounting background. This combination positions our Firm to represent clients in even the most complex probate, trust, and fiduciary litigation. Schedule a consultation or call (214) 984-3410 to discuss your probate and fiduciary litigation needs.