text:
Weaponized Lies
How to Think Critically in the Post-Truth Era
By Daniel J. Levitin
Read by Dan Piraro
Category: Business | Psychology | Audiobooks
Audiobook Download $17.50
Mar 07, 2017 | 443 Minutes
Audiobook Download
Mar 07, 2017 | ISBN 9780525522966 | 443 Minutes
Mar 07, 2017 | ISBN 9780525522966
Buy the Audiobook Download:
About Weaponized Lies
Previously Published as A Field Guide to Lies
We're surrounded by fringe theories, fake news, and pseudo-facts. These lies are getting repeated. New York Times bestselling author Daniel Levitin shows how to disarm these socially devastating inventions and get the American mind back on track. Here are the fundamental lessons in critical thinking that we need to know and share now.
Investigating numerical misinformation, Daniel Levitin shows how mishandled statistics and graphs can give a grossly distorted perspective and lead us to terrible decisions. Wordy arguments on the other hand can easily be persuasive as they drift away from the facts in an appealing yet misguided way. The steps we can take to better evaluate news, advertisements, and reports are clearly detailed. Ultimately, Levitin turns to what underlies our ability to determine if something is true or false: the scientific method. He grapples with the limits of what we can and cannot know. Case studies are offered to demonstrate the applications of logical thinking to quite varied settings, spanning courtroom testimony, medical decision making, magic, modern physics, and conspiracy theories.
This urgently needed book enables us to avoid the extremes of passive gullibility and cynical rejection. As Levitin attests: Truth matters. A post-truth era is an era of willful irrationality, reversing all the great advances humankind has made. Euphemisms like "fringe theories," "extreme views," "alt truth," and even "fake news" can literally be dangerous. Let's call lies what they are and catch those making them in the act.
*Includes a PDF of supplemental graphics on visualizing conditional probabilities
Listen to a sample from Weaponized Lies
Also by Daniel J. Levitin
See all books by Daniel J. Levitin
About Daniel J. Levitin
Daniel J. Levitin, PhD, is a neuroscientist, cognitive psychologist, and bestselling author. He is Founding Dean of Arts & Humanities at the Minerva Schools at KGI in San Francisco, and Professor Emeritus of psychology and neuroscience at McGill University. He… More about Daniel J. Levitin
Audiobook Download | $17.50
Published by Penguin Audio
Mar 07, 2017 | 443 Minutes | ISBN 9780525522966
Waiting for a Goal
Common Sense Management
Roger Fulton
More Awesome Than Money
Jim Dwyer
The End of History Not
Luke Harding
Luke Dormehl
Winner, National Business Book Award
Winner, Mavis Gallant Prize for Non-Fiction, QWF
Finalist, The Donner Prize
Winner, Axiom Business Book Silver Award
"Levitin has written an important book for our times. Everyone should read it — democracy depends on it."—Vicente Fox, 55th President of Mexico
"Levitin is brilliant. Everyone should read Weaponized Lies."—Chris Matthews
"Eloquent."—The Los Angeles Review of Books
"Mr. Levitin is the perfect guide…If everyone could adopt the level of healthy statistical skepticism that Mr. Levitin would like, political debate would be in much better shape."—The Economist
"The timing could not be better … for Daniel J. Levitin's new book… a survival manual for the post-factual era…in the struggle against error and ignorance, lies and mistakes, he is both engaging and rewarding."—Literary Review of Canada
"Who knew that a book about statistics could be so riveting!"—Dallas Public Library
"Confirmation bias is a growing problem in the digital information age. As Daniel Levitin writes, our brain is a giant pattern detector. If we read something that coincides with what we already believe we're more likely to give it credence, while the opposite is not true…The good thing about science is that it's true whether or not you believe in it."—John Cleese
"Misinformation is a part of everyday life in our data-intense, internet-enhanced world. Levitin provides an entertaining and engaging guide to how we can use critical thinking to avoid being fooled. Weaponized Lies is a valuable survival guide to consuming information in the digital age."—Lori Holt, Professor, Department of Psychology and Center for the Neural Basis of Cognition, Carnegie Mellon University
"Our brain is wired to make snap judgments. And those judgments can be very, very wrong. Weaponized Lies…teaches how to separate fact from fringe theories and 'fake news.'"—NPR's Marketplace
"In a post-truth world, Levitin's book is an invaluable primer on how to sort the fact from the fiction."—Sunday Times of London
"A practical guide to better managing today's constant flow of data and to improving critical thinking…A recommended book for creative leaders."— Forbes
"As a lucid guide to critical thinking about statistics, information and assertion it is profoundly welcome"— Observer
"On the internet, nobody knows you're not an expert. Luckily, McGill University Cognitive Psychologist and Weaponized Lies author Daniel J. Levitin has a few tricks to pick out the professors from the phonies."—Business Insider
"A plea for sanity in a world seemingly gone mad…Levitin is an eloquent and enthusiastic exponent."—LA Review of Books
"A lucid guide to critical thinking about statistics, information and assertion, it's profoundly welcome." —The Guardian
"A timely primer on how statistics, polls and information presented as facts can be used by "lying weasels" to obscure the truth. [A]ddresses the careless or lazy critical thinking skills many have developed in the era of internet information overload."—Forward
"A necessary book and one most appropriate to the times we find ourselves in…[an] excursion through how to think about data, how to think about statistics, and how to do so in a systematic way."—The Times Higher Education Supplement
"A cool-headed and witty guide to thinking clearly and rationally, and a deconstruction of sloppy information."—The Irish Times
"Levitin is brilliant regarding all of the ways that information can be manipulated."— Medium
"Regardless of one's political persuasion (apolitical, third party, democratic, or republican) all individuals of this nation would benefit from making the effort to read and understand the concepts presented in this book… eminently easy to read and as a consequence, easy to understand." —Portland Books Review
"Daniel Levitin's field guide is a critical thinking primer for our shrill, data-drenched age. It's an essential tool for really understanding the texts, posts, tweets, magazines, newspapers, podcasts, op-eds, interviews, and speeches that bombard us every day. From the way averages befuddle to the logical fallacies that sneak by us, every page is enlightening."—Charles Duhigg, author of The Power of Habit and Smarter, Faster, Better
"The world is awash with data, but not always with accurate information. Weaponized Lies does a terrific job of illustrating the difference between the two with precision—and delightful good humor."—Charles Wheelan, Senior Lecturer and Policy Fellow, Rockefeller Center, Dartmouth College, author of Naked Economics
"Weaponized Lies by the neuroscientist Daniel Levitin lays out the many ways in which each of us can be fooled and misled by numbers and logic, as well as the modes of critical thinking we will need to overcome this."—The Wall Street Journal
"Valuable tools for anyone willing to evaluate claims and get to the truth of the matter."—Kirkus Reviews
"This useful, entertaining, and highly readable guide is ready to arm everyday citizens with the tools to combat the spread of spurious, and often ridiculous, information."—Library Journal
"[A] book you may want to have close by at all times."—Success Magazine
"Weaponized Lies serves as a kind of Strunk & White for sloppy thinkers."—New York Journal of Books
"Entertaining and filled with helpful hints, Weaponized Lies is a valuable tool for navigating the daily data onslaught."—San Jose Mercury News
"[S]mart and humorous…the tools anyone needs to tell good information from bad are in this definitive guide to critical thinking."—Shelf Awareness
"Exceptional … practical and essential advice."—Big Think
"An entertaining, user-friendly primer on evaluating data wisely."—The Washington Independent Review of Books
"This is a wonderful book. It covers so many of the insights of science, logic, and statistics that the public needs to know, yet are sadly neglected in the education that most of us receive."—Edward K. Cheng, Tarkington Chair of Teaching Excellence and professor of law at Vanderbilt Law School
"Hits on the most important issues around statistical literacy, and uses good examples to illustrate its points. I could not put this book down. Reading it has been a pleasure, believe me. I am so impressed with Levitin's writing style, which is clear and simple, unlike much of the murky stuff that is written by statisticians and many others."—Morris Olitsky, former Vice President, Market Research and Analysis, Prudential Financial, Statistician, U.S.D.A.
"Insightful and entertaining—an excellent work."—Gregg Gascon, Biomedical Informatics, Ohio State University
"Just as Strunk and White taught us how to communicate better, Weaponized Lies is an indispensable guide to thinking better. As Big Data becomes a dominant theme in our culture, we are all obliged to sharpen our critical thinking so as to thwart the forces of obfuscation. Levitin has done a great service here."—Jasper Rine, Professor of Genetics, Genomics, and Development, UC Berkeley
"Not since Huff's classic How to Lie with Statistics has a book so clearly described how numbers can be used to deceive and misdirect. Levitin shows how to critically evaluate claims that charlatans, the media, and politicians would have us believe."—Stan Lazic, Team Leader in Quantitative Biology at AstraZeneca
"A must read! Professor Levitin convinces the reader why critical thinking has become even more crucial in the Information Age. As we are consistently bombarded with information, let's question its veracity and acquire the tools to analyze it."—Isabelle Bajeux-Besnainou, Dean and Professor of Finance, Desautels Faculty of Management, McGill University
"Well researched, and provides a valuable guide to assist the public with a methodology for evaluating the truth behind this cacophony of information that constantly inundates."—Patrick Martin, Magician
"No book could be more timely. An important book for everyone to read. Essential to where western democracies are going."—Janice Stein, Founding Director, Munk School of Global Affairs, University of Toronto
"[A] valuable primer on critical thinking that convincingly illustrates the prevalence of misinformation in everyday life."—Publisher's Weekly
"Levitin belongs to a best-selling group of experts—Daniel Kahneman, Gerd Gigerenzer, David Spiegelhalter, and a few more—who want to put us right on the pitfalls of dubious statistics and the various forms of bias that skew our decisions…There can hardly be a more important message at this moment in history, and until everyone gets it, all are welcome to keep pumping it out and Levitin is perhaps primus inter pares…His message is bracing…[and] all we have to guard against a new Dark Age."—The Arts Desk
Get the latest updates about Daniel J. Levitin


text:
<resources>
    <string name="app_name">AirAware</string>
    <string name="hello_world">Hello World!</string>
</resources>

redpajama_set_name: RedPajamaGithub


text:
Watch Murdoch Mysteries Online
Watch Murdoch Mysteries Full Series Online. A Victorian-era Toronto detective uses then-cutting edge forensic techniques to solve crimes, with the assistance of a female coroner who is also struggling for recognition in the face of tradition, based on the books by Maureen Jennings.
Director: Maureen Jennings
Actors: Helene Joy, Jonny Harris, Lachlan Murdoch, Thomas Craig, Yannick Bisson
Networks: CBC Television, City, Ovation
Human Universe
Watch Human Universe Full Series Online. Professor Brian Cox asks the biggest questions we can ask. Are we alone? Why are we here? What is our future? Join him in…
Watch RUN Full Series Online. Ruby is living a humdrum existence when one day she gets a text inviting her to fulfill a youthful pact, promising true love and self-reinvention,…
Watch Bodyguard Full Series Online. A troubled war veteran is assigned to protect a controversial politician who may be the target of a terror plot.
Genre: Crime, Drama, War & Politics
Watch Barkskins Full Series Online. A disparate group of outcasts and dreamers battle to escape their pasts while navigating the brutal frontier hardships, competing interests, and tangled loyalties at the…
Watch Feel Good Full Series Online. Recovering addict and comedian Mae tries to control the addictive behaviors and intense romanticism that permeate every facet of her life. Life is further…
Mystery Road
Watch Mystery Road Full Series Online. When there is a mysterious disappearance on an outback cattle station, Detective Jay Swan is assigned to investigate. Working with local cop Emma James,…
Watch The Outpost Full Series Online. Talon, the lone survivor of a race called the Blackbloods, sets off to the edge of civilisation to track her family's killers. On her…
Watch The Kids Are Alright Full Series Online. In a working-class neighborhood outside Los Angeles, Mike and Peggy raise eight boisterous boys. There are 10 people, three bedrooms, one bathroom…
Watch The Owl House Full Series Online. An animated fantasy-comedy series that follows Luz, a self-assured teenage girl who accidentally stumbles upon a portal to a magical world where she…
Genre: Action & Adventure, Animation, Comedy, Sci-Fi & Fantasy
90 Day Fiancé: B90 Strikes Back!
Watch 90 Day Fiance: B90 Strikes Back Full Series Online. 90 Day Fiancé couples get a chance to clap back at haters and set the record straight. Cast members from…
If We Built It Today
Watch If We Built It Today Full Series Online. They are some of the world's all-time greatest building projects. Most have stood the test of time, but with today's technology,…
Trailer: Murdoch Mysteries

redpajama_set_name: RedPajamaCommonCrawl


The goal of this research is to develop a physics-based model of the earthquake cycle to assess the full range of seismic behavior that can be expected across a plate boundary.
This team uses remote sensing (synthetic aperture radar, GPS, optical photographs, gravity) and seismological data to investigate the mechanics the lithosphere and fault slip. These measurements can be used to constrain models of rupture and lithosphere dynamics, which include faulting, but also more distributed deformation, such as poroelastic rebound and viscoelastic flow. An important goal is to reconcile long-term (regional tectonics) and short-term (earthquake dynamics) observations and improve our capacity to predict some aspect of the earthquake cycle.
Credits: Barbot S., N. Lapusta and J.-P. Avouac, "Under the Hood of the Earthquake Machine: Toward Predictive Modeling of the Seismic Cycle", Science, 2012.
Tang, Chi-Hsien, Ya-Ju Hsu, Sylvain Barbot, James D. P. Moore, and Wu-Lung Chang. "Lower-crustal rheology and thermal gradient in the Taiwan orogenic belt illuminated by the 1999 Chi-Chi earthquake." Science Advances 5 (2019).
Wang, Teng, Kimberly DeGrandpre, Zhong Lu, and Jeffrey T. Freymueller. "Complex surface deformation of Akutan volcano, Alaska revealed from InSAR time series." International Journal of Applied Earth Observation and Geoinformation 64 (2018): 171-180.
Wang, Teng, Shengji Wei, Xuhua Shi, Qiang Qiu, Linlin Li, Dongju Peng, Ray J. Weldon, II, and Sylvain Barbot. "The 2016 Kaikoura earthquake: Simultaneous rupture of the subduction interface and overlying faults." Earth and Planetary Science Letters 482, no. 44-51 (2018).
The overarching goal of our studies is to characterise the strength of the lithosphere from geodetic to geologic time-scales and its implications for landscape evolution and mantle dynamics.
We investigate the physics underlying seismic hazards by modelling the dynamics of fault slip and plastic flow.


About Rolex Daytona Watches. The Rolex Cosmograph Daytona watch, debuted in 1963, was created to meet the demands of professional race car drivers.
Steady People's Ideal Fake Rolex Daytona Watches Online. When looking back the watch history, you can find that it has gone through several centuries, giving you different kinds of ways of grasping the time.


text:
declare module spine {
    class Animation {
        name: string;
        timelines: Array<Timeline>;
        timelineIds: StringSet;
        duration: number;
        constructor(name: string, timelines: Array<Timeline>, duration: number);
        setTimelines(timelines: Array<Timeline>): void;
        hasTimeline(ids: string[]): boolean;
        apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    enum MixBlend {
        setup = 0,
        first = 1,
        replace = 2,
        add = 3
    }
    enum MixDirection {
        // @ts-ignore
        mixIn = 0,
        // @ts-ignore
        mixOut = 1
    }
    abstract class Timeline {
        propertyIds: string[];
        frames: ArrayLike<number>;
        constructor(frameCount: number, propertyIds: string[]);
        getPropertyIds(): string[];
        getFrameEntries(): number;
        getFrameCount(): number;
        getDuration(): number;
        // @ts-ignore
        abstract apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
        static search1(frames: ArrayLike<number>, time: number): number;
        static search(frames: ArrayLike<number>, time: number, step: number): number;
    }
    interface BoneTimeline {
        boneIndex: number;
    }
    interface SlotTimeline {
        slotIndex: number;
    }
    abstract class CurveTimeline extends Timeline {
        protected curves: ArrayLike<number>;
        constructor(frameCount: number, bezierCount: number, propertyIds: string[]);
        setLinear(frame: number): void;
        setStepped(frame: number): void;
        shrink(bezierCount: number): void;
        setBezier(bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: number): void;
        getBezierValue(time: number, frameIndex: number, valueOffset: number, i: number): number;
    }
    abstract class CurveTimeline1 extends CurveTimeline {
        constructor(frameCount: number, bezierCount: number, propertyId: string);
        getFrameEntries(): number;
        setFrame(frame: number, time: number, value: number): void;
        getCurveValue(time: number): number;
    }
    abstract class CurveTimeline2 extends CurveTimeline {
        constructor(frameCount: number, bezierCount: number, propertyId1: string, propertyId2: string);
        getFrameEntries(): number;
        setFrame(frame: number, time: number, value1: number, value2: number): void;
    }
    class RotateTimeline extends CurveTimeline1 implements BoneTimeline {
        boneIndex: number;
        constructor(frameCount: number, bezierCount: number, boneIndex: number);
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class TranslateTimeline extends CurveTimeline2 implements BoneTimeline {
        boneIndex: number;
        constructor(frameCount: number, bezierCount: number, boneIndex: number);
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class TranslateXTimeline extends CurveTimeline1 implements BoneTimeline {
        boneIndex: number;
        constructor(frameCount: number, bezierCount: number, boneIndex: number);
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class TranslateYTimeline extends CurveTimeline1 implements BoneTimeline {
        boneIndex: number;
        constructor(frameCount: number, bezierCount: number, boneIndex: number);
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class ScaleTimeline extends CurveTimeline2 implements BoneTimeline {
        boneIndex: number;
        constructor(frameCount: number, bezierCount: number, boneIndex: number);
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class ScaleXTimeline extends CurveTimeline1 implements BoneTimeline {
        boneIndex: number;
        constructor(frameCount: number, bezierCount: number, boneIndex: number);
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class ScaleYTimeline extends CurveTimeline1 implements BoneTimeline {
        boneIndex: number;
        constructor(frameCount: number, bezierCount: number, boneIndex: number);
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class ShearTimeline extends CurveTimeline2 implements BoneTimeline {
        boneIndex: number;
        constructor(frameCount: number, bezierCount: number, boneIndex: number);
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class ShearXTimeline extends CurveTimeline1 implements BoneTimeline {
        boneIndex: number;
        constructor(frameCount: number, bezierCount: number, boneIndex: number);
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class ShearYTimeline extends CurveTimeline1 implements BoneTimeline {
        boneIndex: number;
        constructor(frameCount: number, bezierCount: number, boneIndex: number);
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class RGBATimeline extends CurveTimeline implements SlotTimeline {
        slotIndex: number;
        constructor(frameCount: number, bezierCount: number, slotIndex: number);
        getFrameEntries(): number;
        setFrame(frame: number, time: number, r: number, g: number, b: number, a: number): void;
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class RGBTimeline extends CurveTimeline implements SlotTimeline {
        slotIndex: number;
        constructor(frameCount: number, bezierCount: number, slotIndex: number);
        getFrameEntries(): number;
        setFrame(frame: number, time: number, r: number, g: number, b: number): void;
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class AlphaTimeline extends CurveTimeline1 implements SlotTimeline {
        slotIndex: number;
        constructor(frameCount: number, bezierCount: number, slotIndex: number);
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class RGBA2Timeline extends CurveTimeline implements SlotTimeline {
        slotIndex: number;
        constructor(frameCount: number, bezierCount: number, slotIndex: number);
        getFrameEntries(): number;
        setFrame(frame: number, time: number, r: number, g: number, b: number, a: number, r2: number, g2: number, b2: number): void;
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class RGB2Timeline extends CurveTimeline implements SlotTimeline {
        slotIndex: number;
        constructor(frameCount: number, bezierCount: number, slotIndex: number);
        getFrameEntries(): number;
        setFrame(frame: number, time: number, r: number, g: number, b: number, r2: number, g2: number, b2: number): void;
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class AttachmentTimeline extends Timeline implements SlotTimeline {
        slotIndex: number;
        attachmentNames: Array<string>;
        constructor(frameCount: number, slotIndex: number);
        getFrameCount(): number;
        setFrame(frame: number, time: number, attachmentName: string): void;
        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
        setAttachment(skeleton: Skeleton, slot: Slot, attachmentName: string): void;
    }
    class DeformTimeline extends CurveTimeline implements SlotTimeline {
        slotIndex: number;
        attachment: VertexAttachment;
        vertices: Array<ArrayLike<number>>;
        constructor(frameCount: number, bezierCount: number, slotIndex: number, attachment: VertexAttachment);
        getFrameCount(): number;
        setFrame(frame: number, time: number, vertices: ArrayLike<number>): void;
        setBezier(bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: number): void;
        getCurvePercent(time: number, frame: number): number;
        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class EventTimeline extends Timeline {
        static propertyIds: string[];
        events: Array<Event>;
        constructor(frameCount: number);
        getFrameCount(): number;
        setFrame(frame: number, event: Event): void;
        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class DrawOrderTimeline extends Timeline {
        static propertyIds: string[];
        drawOrders: Array<Array<number>>;
        constructor(frameCount: number);
        getFrameCount(): number;
        setFrame(frame: number, time: number, drawOrder: Array<number>): void;
        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class IkConstraintTimeline extends CurveTimeline {
        ikConstraintIndex: number;
        constructor(frameCount: number, bezierCount: number, ikConstraintIndex: number);
        getFrameEntries(): number;
        setFrame(frame: number, time: number, mix: number, softness: number, bendDirection: number, compress: boolean, stretch: boolean): void;
        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class TransformConstraintTimeline extends CurveTimeline {
        transformConstraintIndex: number;
        constructor(frameCount: number, bezierCount: number, transformConstraintIndex: number);
        getFrameEntries(): number;
        setFrame(frame: number, time: number, mixRotate: number, mixX: number, mixY: number, mixScaleX: number, mixScaleY: number, mixShearY: number): void;
        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class PathConstraintPositionTimeline extends CurveTimeline1 {
        pathConstraintIndex: number;
        constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number);
        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class PathConstraintSpacingTimeline extends CurveTimeline1 {
        pathConstraintIndex: number;
        constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number);
        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
    class PathConstraintMixTimeline extends CurveTimeline {
        pathConstraintIndex: number;
        constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number);
        getFrameEntries(): number;
        setFrame(frame: number, time: number, mixRotate: number, mixX: number, mixY: number): void;
        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
    }
}
declare module spine {
    class AnimationState {
        private static emptyAnimation;
        data: AnimationStateData;
        tracks: TrackEntry[];
        timeScale: number;
        unkeyedState: number;
        events: Event[];
        listeners: AnimationStateListener[];
        queue: EventQueue;
        propertyIDs: StringSet;
        animationsChanged: boolean;
        trackEntryPool: Pool<TrackEntry>;
        constructor(data: AnimationStateData);
        update(delta: number): void;
        updateMixingFrom(to: TrackEntry, delta: number): boolean;
        apply(skeleton: Skeleton): boolean;
        applyMixingFrom(to: TrackEntry, skeleton: Skeleton, blend: MixBlend): number;
        applyAttachmentTimeline(timeline: AttachmentTimeline, skeleton: Skeleton, time: number, blend: MixBlend, attachments: boolean): void;
        setAttachment(skeleton: Skeleton, slot: Slot, attachmentName: string, attachments: boolean): void;
        applyRotateTimeline(timeline: RotateTimeline, skeleton: Skeleton, time: number, alpha: number, blend: MixBlend, timelinesRotation: Array<number>, i: number, firstFrame: boolean): void;
        queueEvents(entry: TrackEntry, animationTime: number): void;
        clearTracks(): void;
        clearTrack(trackIndex: number): void;
        setCurrent(index: number, current: TrackEntry, interrupt: boolean): void;
        setAnimation(trackIndex: number, animationName: string, loop?: boolean): TrackEntry;
        setAnimationWith(trackIndex: number, animation: Animation, loop?: boolean): TrackEntry;
        addAnimation(trackIndex: number, animationName: string, loop?: boolean, delay?: number): TrackEntry;
        addAnimationWith(trackIndex: number, animation: Animation, loop?: boolean, delay?: number): TrackEntry;
        setEmptyAnimation(trackIndex: number, mixDuration?: number): TrackEntry;
        addEmptyAnimation(trackIndex: number, mixDuration?: number, delay?: number): TrackEntry;
        setEmptyAnimations(mixDuration?: number): void;
        expandToIndex(index: number): TrackEntry;
        trackEntry(trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry): TrackEntry;
        clearNext(entry: TrackEntry): void;
        _animationsChanged(): void;
        computeHold(entry: TrackEntry): void;
        getCurrent(trackIndex: number): TrackEntry;
        addListener(listener: AnimationStateListener): void;
        removeListener(listener: AnimationStateListener): void;
        clearListeners(): void;
        clearListenerNotifications(): void;
    }
    class TrackEntry {
        animation: Animation;
        previous: TrackEntry;
        next: TrackEntry;
        mixingFrom: TrackEntry;
        mixingTo: TrackEntry;
        listener: AnimationStateListener;
        trackIndex: number;
        loop: boolean;
        holdPrevious: boolean;
        reverse: boolean;
        eventThreshold: number;
        attachmentThreshold: number;
        drawOrderThreshold: number;
        animationStart: number;
        animationEnd: number;
        animationLast: number;
        nextAnimationLast: number;
        delay: number;
        trackTime: number;
        trackLast: number;
        nextTrackLast: number;
        trackEnd: number;
        timeScale: number;
        alpha: number;
        mixTime: number;
        mixDuration: number;
        interruptAlpha: number;
        totalAlpha: number;
        mixBlend: MixBlend;
        timelineMode: number[];
        timelineHoldMix: TrackEntry[];
        timelinesRotation: number[];
        reset(): void;
        getAnimationTime(): number;
        setAnimationLast(animationLast: number): void;
        isComplete(): boolean;
        resetRotationDirections(): void;
        getTrackComplete(): number;
    }
    class EventQueue {
        objects: Array<any>;
        drainDisabled: boolean;
        animState: AnimationState;
        constructor(animState: AnimationState);
        start(entry: TrackEntry): void;
        interrupt(entry: TrackEntry): void;
        end(entry: TrackEntry): void;
        dispose(entry: TrackEntry): void;
        complete(entry: TrackEntry): void;
        event(entry: TrackEntry, event: Event): void;
        drain(): void;
        clear(): void;
    }
    enum EventType {
        start = 0,
        interrupt = 1,
        end = 2,
        dispose = 3,
        complete = 4,
        event = 5
    }
    interface AnimationStateListener {
        start(entry: TrackEntry): void;
        interrupt(entry: TrackEntry): void;
        end(entry: TrackEntry): void;
        dispose(entry: TrackEntry): void;
        complete(entry: TrackEntry): void;
        event(entry: TrackEntry, event: Event): void;
    }
    // @ts-ignore
    abstract class AnimationStateAdapter implements AnimationStateListener {
        start(entry: TrackEntry): void;
        interrupt(entry: TrackEntry): void;
        end(entry: TrackEntry): void;
        dispose(entry: TrackEntry): void;
        complete(entry: TrackEntry): void;
        event(entry: TrackEntry, event: Event): void;
    }
}
declare module spine {
    class AnimationStateData {
        skeletonData: SkeletonData;
        animationToMixTime: Map<number>;
        defaultMix: number;
        constructor(skeletonData: SkeletonData);
        setMix(fromName: string, toName: string, duration: number): void;
        setMixWith(from: Animation, to: Animation, duration: number): void;
        getMix(from: Animation, to: Animation): number;
    }
}
declare module spine {
    class AssetManager implements Disposable {
        private pathPrefix;
        private textureLoader;
        private downloader;
        private assets;
        private errors;
        private toLoad;
        private loaded;
        constructor(textureLoader: (image: HTMLImageElement | ImageBitmap) => Texture, pathPrefix?: string, downloader?: Downloader);
        private start;
        private success;
        private error;
        setRawDataURI(path: string, data: string): void;
        loadBinary(path: string, success?: (path: string, binary: Uint8Array) => void, error?: (path: string, message: string) => void): void;
        loadText(path: string, success?: (path: string, text: string) => void, error?: (path: string, message: string) => void): void;
        loadJson(path: string, success?: (path: string, object: object) => void, error?: (path: string, message: string) => void): void;
        loadTexture(path: string, success?: (path: string, texture: Texture) => void, error?: (path: string, message: string) => void): void;
        loadTextureAtlas(path: string, success?: (path: string, atlas: TextureAtlas) => void, error?: (path: string, message: string) => void): void;
        get(path: string): any;
        require(path: string): any;
        remove(path: string): any;
        removeAll(): void;
        isLoadingComplete(): boolean;
        getToLoad(): number;
        getLoaded(): number;
        dispose(): void;
        hasErrors(): boolean;
        getErrors(): Map<string>;
    }
    class Downloader {
        private callbacks;
        rawDataUris: Map<string>;
        downloadText(url: string, success: (data: string) => void, error: (status: number, responseText: string) => void): void;
        downloadJson(url: string, success: (data: object) => void, error: (status: number, responseText: string) => void): void;
        downloadBinary(url: string, success: (data: Uint8Array) => void, error: (status: number, responseText: string) => void): void;
        private start;
        private finish;
    }
}
declare module spine {
    class AtlasAttachmentLoader implements AttachmentLoader {
        atlas: TextureAtlas;
        constructor(atlas: TextureAtlas);
        newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
        newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
        newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
        newPathAttachment(skin: Skin, name: string): PathAttachment;
        newPointAttachment(skin: Skin, name: string): PointAttachment;
        newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
    }
}
declare module spine {
    class Bone implements Updatable {
        data: BoneData;
        skeleton: Skeleton;
        parent: Bone;
        children: Bone[];
        x: number;
        y: number;
        rotation: number;
        scaleX: number;
        scaleY: number;
        shearX: number;
        shearY: number;
        ax: number;
        ay: number;
        arotation: number;
        ascaleX: number;
        ascaleY: number;
        ashearX: number;
        ashearY: number;
        a: number;
        b: number;
        c: number;
        d: number;
        worldY: number;
        worldX: number;
        sorted: boolean;
        active: boolean;
        constructor(data: BoneData, skeleton: Skeleton, parent: Bone);
        isActive(): boolean;
        update(): void;
        updateWorldTransform(): void;
        updateWorldTransformWith(x: number, y: number, rotation: number, scaleX: number, scaleY: number, shearX: number, shearY: number): void;
        setToSetupPose(): void;
        getWorldRotationX(): number;
        getWorldRotationY(): number;
        getWorldScaleX(): number;
        getWorldScaleY(): number;
        updateAppliedTransform(): void;
        worldToLocal(world: Vector2): Vector2;
        localToWorld(local: Vector2): Vector2;
        worldToLocalRotation(worldRotation: number): number;
        localToWorldRotation(localRotation: number): number;
        rotateWorld(degrees: number): void;
    }
}
declare module spine {
    class BoneData {
        index: number;
        name: string;
        parent: BoneData;
        length: number;
        x: number;
        y: number;
        rotation: number;
        scaleX: number;
        scaleY: number;
        shearX: number;
        shearY: number;
        transformMode: TransformMode;
        skinRequired: boolean;
        color: Color;
        constructor(index: number, name: string, parent: BoneData);
    }
    enum TransformMode {
        Normal = 0,
        OnlyTranslation = 1,
        NoRotationOrReflection = 2,
        NoScale = 3,
        NoScaleOrReflection = 4
    }
}
declare module spine {
    // @ts-ignore
    abstract class ConstraintData {
        name: string;
        order: number;
        skinRequired: boolean;
        constructor(name: string, order: number, skinRequired: boolean);
    }
}
declare module spine {
    class Event {
        data: EventData;
        intValue: number;
        floatValue: number;
        stringValue: string;
        time: number;
        volume: number;
        balance: number;
        constructor(time: number, data: EventData);
    }
}
declare module spine {
    class EventData {
        name: string;
        intValue: number;
        floatValue: number;
        stringValue: string;
        audioPath: string;
        volume: number;
        balance: number;
        constructor(name: string);
    }
}
declare module spine {
    class IkConstraint implements Updatable {
        data: IkConstraintData;
        bones: Array<Bone>;
        target: Bone;
        bendDirection: number;
        compress: boolean;
        stretch: boolean;
        mix: number;
        softness: number;
        active: boolean;
        constructor(data: IkConstraintData, skeleton: Skeleton);
        isActive(): boolean;
        update(): void;
        apply1(bone: Bone, targetX: number, targetY: number, compress: boolean, stretch: boolean, uniform: boolean, alpha: number): void;
        apply2(parent: Bone, child: Bone, targetX: number, targetY: number, bendDir: number, stretch: boolean, uniform: boolean, softness: number, alpha: number): void;
    }
}
declare module spine {
    class IkConstraintData extends ConstraintData {
        bones: BoneData[];
        target: BoneData;
        bendDirection: number;
        compress: boolean;
        stretch: boolean;
        uniform: boolean;
        mix: number;
        softness: number;
        constructor(name: string);
    }
}
declare module spine {
    class PathConstraint implements Updatable {
        static NONE: number;
        static BEFORE: number;
        static AFTER: number;
        static epsilon: number;
        data: PathConstraintData;
        bones: Array<Bone>;
        target: Slot;
        position: number;
        spacing: number;
        mixRotate: number;
        mixX: number;
        mixY: number;
        spaces: number[];
        positions: number[];
        world: number[];
        curves: number[];
        lengths: number[];
        segments: number[];
        active: boolean;
        constructor(data: PathConstraintData, skeleton: Skeleton);
        isActive(): boolean;
        update(): void;
        computeWorldPositions(path: PathAttachment, spacesCount: number, tangents: boolean): number[];
        addBeforePosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
        addAfterPosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
        addCurvePosition(p: number, x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, out: Array<number>, o: number, tangents: boolean): void;
    }
}
declare module spine {
    class PathConstraintData extends ConstraintData {
        bones: BoneData[];
        target: SlotData;
        positionMode: PositionMode;
        spacingMode: SpacingMode;
        rotateMode: RotateMode;
        offsetRotation: number;
        position: number;
        spacing: number;
        mixRotate: number;
        mixX: number;
        mixY: number;
        constructor(name: string);
    }
    enum PositionMode {
        Fixed = 0,
        Percent = 1
    }
    enum SpacingMode {
        Length = 0,
        Fixed = 1,
        Percent = 2,
        Proportional = 3
    }
    enum RotateMode {
        Tangent = 0,
        Chain = 1,
        ChainScale = 2
    }
}
declare module spine {
    class Skeleton {
        data: SkeletonData;
        bones: Array<Bone>;
        slots: Array<Slot>;
        drawOrder: Array<Slot>;
        ikConstraints: Array<IkConstraint>;
        transformConstraints: Array<TransformConstraint>;
        pathConstraints: Array<PathConstraint>;
        _updateCache: Updatable[];
        skin: Skin;
        color: Color;
        time: number;
        scaleX: number;
        scaleY: number;
        x: number;
        y: number;
        constructor(data: SkeletonData);
        updateCache(): void;
        sortIkConstraint(constraint: IkConstraint): void;
        sortPathConstraint(constraint: PathConstraint): void;
        sortTransformConstraint(constraint: TransformConstraint): void;
        sortPathConstraintAttachment(skin: Skin, slotIndex: number, slotBone: Bone): void;
        sortPathConstraintAttachmentWith(attachment: Attachment, slotBone: Bone): void;
        sortBone(bone: Bone): void;
        sortReset(bones: Array<Bone>): void;
        updateWorldTransform(): void;
        updateWorldTransformWith(parent: Bone): void;
        setToSetupPose(): void;
        setBonesToSetupPose(): void;
        setSlotsToSetupPose(): void;
        getRootBone(): Bone;
        findBone(boneName: string): Bone;
        findBoneIndex(boneName: string): number;
        findSlot(slotName: string): Slot;
        findSlotIndex(slotName: string): number;
        setSkinByName(skinName: string): void;
        setSkin(newSkin: Skin): void;
        getAttachmentByName(slotName: string, attachmentName: string): Attachment;
        getAttachment(slotIndex: number, attachmentName: string): Attachment;
        setAttachment(slotName: string, attachmentName: string): void;
        findIkConstraint(constraintName: string): IkConstraint;
        findTransformConstraint(constraintName: string): TransformConstraint;
        findPathConstraint(constraintName: string): PathConstraint;
        getBounds(offset: Vector2, size: Vector2, temp?: Array<number>): void;
        update(delta: number): void;
    }
}
declare module spine {
    // @ts-ignore
    class SkeletonBinary {
        scale: number;
        attachmentLoader: AttachmentLoader;
        private linkedMeshes;
        constructor(attachmentLoader: AttachmentLoader);
        readSkeletonData(binary: Uint8Array): SkeletonData;
        private readSkin;
        private readAttachment;
        private readVertices;
        private readFloatArray;
        private readShortArray;
        private readAnimation;
    }
}
declare module spine {
    class SkeletonBounds {
        minX: number;
        minY: number;
        maxX: number;
        maxY: number;
        boundingBoxes: BoundingBoxAttachment[];
        polygons: ArrayLike<number>[];
        private polygonPool;
        update(skeleton: Skeleton, updateAabb: boolean): void;
        aabbCompute(): void;
        aabbContainsPoint(x: number, y: number): boolean;
        aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number): boolean;
        aabbIntersectsSkeleton(bounds: SkeletonBounds): boolean;
        containsPoint(x: number, y: number): BoundingBoxAttachment;
        containsPointPolygon(polygon: ArrayLike<number>, x: number, y: number): boolean;
        intersectsSegment(x1: number, y1: number, x2: number, y2: number): BoundingBoxAttachment;
        intersectsSegmentPolygon(polygon: ArrayLike<number>, x1: number, y1: number, x2: number, y2: number): boolean;
        getPolygon(boundingBox: BoundingBoxAttachment): ArrayLike<number>;
        getWidth(): number;
        getHeight(): number;
    }
}
declare module spine {
    class SkeletonClipping {
        private triangulator;
        private clippingPolygon;
        private clipOutput;
        clippedVertices: number[];
        clippedTriangles: number[];
        private scratch;
        private clipAttachment;
        private clippingPolygons;
        clipStart(slot: Slot, clip: ClippingAttachment): number;
        clipEndWithSlot(slot: Slot): void;
        clipEnd(): void;
        isClipping(): boolean;
        clipTriangles(vertices: ArrayLike<number>, verticesLength: number, triangles: ArrayLike<number>, trianglesLength: number, uvs: ArrayLike<number>, light: Color, dark: Color, twoColor: boolean): void;
        clip(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, clippingArea: Array<number>, output: Array<number>): boolean;
        static makeClockwise(polygon: ArrayLike<number>): void;
    }
}
declare module spine {
    class SkeletonData {
        name: string;
        bones: BoneData[];
        slots: SlotData[];
        skins: Skin[];
        defaultSkin: Skin;
        events: EventData[];
        animations: Animation[];
        ikConstraints: IkConstraintData[];
        transformConstraints: TransformConstraintData[];
        pathConstraints: PathConstraintData[];
        x: number;
        y: number;
        width: number;
        height: number;
        version: string;
        hash: string;
        fps: number;
        imagesPath: string;
        audioPath: string;
        findBone(boneName: string): BoneData;
        findBoneIndex(boneName: string): number;
        findSlot(slotName: string): SlotData;
        findSlotIndex(slotName: string): number;
        findSkin(skinName: string): Skin;
        findEvent(eventDataName: string): EventData;
        findAnimation(animationName: string): Animation;
        findIkConstraint(constraintName: string): IkConstraintData;
        findTransformConstraint(constraintName: string): TransformConstraintData;
        findPathConstraint(constraintName: string): PathConstraintData;
    }
}
declare module spine {
    class SkeletonJson {
        attachmentLoader: AttachmentLoader;
        scale: number;
        private linkedMeshes;
        constructor(attachmentLoader: AttachmentLoader);
        readSkeletonData(json: string | any): SkeletonData;
        readAttachment(map: any, skin: Skin, slotIndex: number, name: string, skeletonData: SkeletonData): Attachment;
        readVertices(map: any, attachment: VertexAttachment, verticesLength: number): void;
        readAnimation(map: any, name: string, skeletonData: SkeletonData): void;
    }
}
declare module spine {
    // @ts-ignore
    class SkinEntry {
        slotIndex: number;
        name: string;
        attachment: Attachment;
        constructor(slotIndex: number, name: string, attachment: Attachment);
    }
    class Skin {
        name: string;
        attachments: Map<Attachment>[];
        bones: BoneData[];
        constraints: ConstraintData[];
        constructor(name: string);
        setAttachment(slotIndex: number, name: string, attachment: Attachment): void;
        addSkin(skin: Skin): void;
        copySkin(skin: Skin): void;
        getAttachment(slotIndex: number, name: string): Attachment;
        removeAttachment(slotIndex: number, name: string): void;
        getAttachments(): Array<SkinEntry>;
        getAttachmentsForSlot(slotIndex: number, attachments: Array<SkinEntry>): void;
        clear(): void;
        attachAll(skeleton: Skeleton, oldSkin: Skin): void;
    }
}
declare module spine {
    class Slot {
        data: SlotData;
        bone: Bone;
        color: Color;
        darkColor: Color;
        attachment: Attachment;
        private attachmentTime;
        attachmentState: number;
        deform: number[];
        constructor(data: SlotData, bone: Bone);
        getSkeleton(): Skeleton;
        getAttachment(): Attachment;
        setAttachment(attachment: Attachment): void;
        setAttachmentTime(time: number): void;
        getAttachmentTime(): number;
        setToSetupPose(): void;
    }
}
declare module spine {
    class SlotData {
        index: number;
        name: string;
        boneData: BoneData;
        color: Color;
        darkColor: Color;
        attachmentName: string;
        blendMode: BlendMode;
        constructor(index: number, name: string, boneData: BoneData);
    }
    enum BlendMode {
        Normal = 0,
        Additive = 1,
        Multiply = 2,
        Screen = 3
    }
}
declare module spine {
    abstract class Texture {
        protected _image: HTMLImageElement | ImageBitmap;
        constructor(image: HTMLImageElement | ImageBitmap);
        getImage(): HTMLImageElement | ImageBitmap;
        abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
        abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
        abstract dispose(): void;
    }
    enum TextureFilter {
        Nearest = 9728,
        Linear = 9729,
        MipMap = 9987,
        MipMapNearestNearest = 9984,
        MipMapLinearNearest = 9985,
        MipMapNearestLinear = 9986,
        MipMapLinearLinear = 9987
    }
    enum TextureWrap {
        MirroredRepeat = 33648,
        ClampToEdge = 33071,
        Repeat = 10497
    }
    class TextureRegion {
        renderObject: any;
        u: number;
        v: number;
        u2: number;
        v2: number;
        width: number;
        height: number;
        degrees: number;
        offsetX: number;
        offsetY: number;
        originalWidth: number;
        originalHeight: number;
    }
    class FakeTexture extends Texture {
        setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
        setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
        dispose(): void;
    }
}
declare module spine {
    class TextureAtlas implements Disposable {
        pages: TextureAtlasPage[];
        regions: TextureAtlasRegion[];
        constructor(atlasText: string);
        findRegion(name: string): TextureAtlasRegion;
        setTextures(assetManager: AssetManager, pathPrefix?: string): void;
        dispose(): void;
    }
    class TextureAtlasPage {
        name: string;
        minFilter: TextureFilter;
        magFilter: TextureFilter;
        uWrap: TextureWrap;
        vWrap: TextureWrap;
        texture: Texture;
        width: number;
        height: number;
        pma: boolean;
        setTexture(texture: Texture): void;
    }
    class TextureAtlasRegion extends TextureRegion {
        page: TextureAtlasPage;
        name: string;
        x: number;
        y: number;
        offsetX: number;
        offsetY: number;
        originalWidth: number;
        originalHeight: number;
        index: number;
        degrees: number;
        names: string[];
        values: number[][];
    }
}
declare module spine {
    class TransformConstraint implements Updatable {
        data: TransformConstraintData;
        bones: Array<Bone>;
        target: Bone;
        mixRotate: number;
        mixX: number;
        mixY: number;
        mixScaleX: number;
        mixScaleY: number;
        mixShearY: number;
        temp: Vector2;
        active: boolean;
        constructor(data: TransformConstraintData, skeleton: Skeleton);
        isActive(): boolean;
        update(): void;
        applyAbsoluteWorld(): void;
        applyRelativeWorld(): void;
        applyAbsoluteLocal(): void;
        applyRelativeLocal(): void;
    }
}
declare module spine {
    class TransformConstraintData extends ConstraintData {
        bones: BoneData[];
        target: BoneData;
        mixRotate: number;
        mixX: number;
        mixY: number;
        mixScaleX: number;
        mixScaleY: number;
        mixShearY: number;
        offsetRotation: number;
        offsetX: number;
        offsetY: number;
        offsetScaleX: number;
        offsetScaleY: number;
        offsetShearY: number;
        relative: boolean;
        local: boolean;
        constructor(name: string);
    }
}
declare module spine {
    class Triangulator {
        private convexPolygons;
        private convexPolygonsIndices;
        private indicesArray;
        private isConcaveArray;
        private triangles;
        private polygonPool;
        private polygonIndicesPool;
        triangulate(verticesArray: ArrayLike<number>): Array<number>;
        decompose(verticesArray: Array<number>, triangles: Array<number>): Array<Array<number>>;
        private static isConcave;
        private static positiveArea;
        private static winding;
    }
}
declare module spine {
    interface Updatable {
        update(): void;
        isActive(): boolean;
    }
}
declare module spine {
    interface Map<T> {
        // @ts-ignore
        [key: string]: T;
    }
    class IntSet {
        array: number[];
        add(value: number): boolean;
        contains(value: number): boolean;
        remove(value: number): void;
        clear(): void;
    }
    class StringSet {
        entries: Map<boolean>;
        size: number;
        add(value: string): boolean;
        addAll(values: string[]): boolean;
        contains(value: string): boolean;
        clear(): void;
    }
    interface Disposable {
        dispose(): void;
    }
    interface Restorable {
        restore(): void;
    }
    class Color {
        r: number;
        g: number;
        b: number;
        a: number;
        static WHITE: Color;
        static RED: Color;
        static GREEN: Color;
        static BLUE: Color;
        static MAGENTA: Color;
        constructor(r?: number, g?: number, b?: number, a?: number);
        set(r: number, g: number, b: number, a: number): this;
        setFromColor(c: Color): this;
        setFromString(hex: string): this;
        add(r: number, g: number, b: number, a: number): this;
        clamp(): this;
        static rgba8888ToColor(color: Color, value: number): void;
        static rgb888ToColor(color: Color, value: number): void;
        static fromString(hex: string): Color;
    }
    class MathUtils {
        static PI: number;
        static PI2: number;
        static radiansToDegrees: number;
        static radDeg: number;
        static degreesToRadians: number;
        static degRad: number;
        static clamp(value: number, min: number, max: number): number;
        static cosDeg(degrees: number): number;
        static sinDeg(degrees: number): number;
        static signum(value: number): number;
        static toInt(x: number): number;
        static cbrt(x: number): number;
        static randomTriangular(min: number, max: number): number;
        static randomTriangularWith(min: number, max: number, mode: number): number;
        static isPowerOfTwo(value: number): boolean;
    }
    abstract class Interpolation {
        protected abstract applyInternal(a: number): number;
        apply(start: number, end: number, a: number): number;
    }
    class Pow extends Interpolation {
        protected power: number;
        constructor(power: number);
        applyInternal(a: number): number;
    }
    class PowOut extends Pow {
        constructor(power: number);
        applyInternal(a: number): number;
    }
    class Utils {
        static SUPPORTS_TYPED_ARRAYS: boolean;
        static arrayCopy<T>(source: ArrayLike<T>, sourceStart: number, dest: ArrayLike<T>, destStart: number, numElements: number): void;
        static arrayFill<T>(array: ArrayLike<T>, fromIndex: number, toIndex: number, value: T): void;
        static setArraySize<T>(array: Array<T>, size: number, value?: any): Array<T>;
        static ensureArrayCapacity<T>(array: Array<T>, size: number, value?: any): Array<T>;
        static newArray<T>(size: number, defaultValue: T): Array<T>;
        static newFloatArray(size: number): ArrayLike<number>;
        static newShortArray(size: number): ArrayLike<number>;
        static toFloatArray(array: Array<number>): number[] | Float32Array;
        static toSinglePrecision(value: number): number;
        static webkit602BugfixHelper(alpha: number, blend: MixBlend): void;
        static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean;
        static enumValue(type: any, name: string): any;
    }
    class DebugUtils {
        static logBones(skeleton: Skeleton): void;
    }
    class Pool<T> {
        private items;
        private instantiator;
        constructor(instantiator: () => T);
        obtain(): T;
        free(item: T): void;
        freeAll(items: ArrayLike<T>): void;
        clear(): void;
    }
    class Vector2 {
        x: number;
        y: number;
        constructor(x?: number, y?: number);
        set(x: number, y: number): Vector2;
        length(): number;
        normalize(): this;
    }
    class TimeKeeper {
        maxDelta: number;
        framesPerSecond: number;
        delta: number;
        totalTime: number;
        private lastTime;
        private frameCount;
        private frameTime;
        update(): void;
    }
    interface ArrayLike<T> {
        length: number;
        // @ts-ignore
        [n: number]: T;
    }
    class WindowedMean {
        values: Array<number>;
        addedValues: number;
        lastValue: number;
        mean: number;
        dirty: boolean;
        constructor(windowSize?: number);
        hasEnoughData(): boolean;
        addValue(value: number): void;
        getMean(): number;
    }
}
declare module spine {
    interface VertexEffect {
        begin(skeleton: Skeleton): void;
        transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
        end(): void;
    }
}
interface Math {
    fround(n: number): number;
}
declare module spine {
    abstract class Attachment {
        name: string;
        constructor(name: string);
        abstract copy(): Attachment;
    }
    abstract class VertexAttachment extends Attachment {
        private static nextID;
        id: number;
        bones: Array<number>;
        vertices: ArrayLike<number>;
        worldVerticesLength: number;
        deformAttachment: VertexAttachment;
        constructor(name: string);
        computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
        copyTo(attachment: VertexAttachment): void;
    }
}
declare module spine {
    interface AttachmentLoader {
        newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
        newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
        newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
        newPathAttachment(skin: Skin, name: string): PathAttachment;
        newPointAttachment(skin: Skin, name: string): PointAttachment;
        newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
    }
}
declare module spine {
    class BoundingBoxAttachment extends VertexAttachment {
        color: Color;
        constructor(name: string);
        copy(): Attachment;
    }
}
declare module spine {
    class ClippingAttachment extends VertexAttachment {
        endSlot: SlotData;
        color: Color;
        constructor(name: string);
        copy(): Attachment;
    }
}
declare module spine {
    class MeshAttachment extends VertexAttachment {
        region: TextureRegion;
        path: string;
        regionUVs: ArrayLike<number>;
        uvs: ArrayLike<number>;
        triangles: Array<number>;
        color: Color;
        width: number;
        height: number;
        hullLength: number;
        edges: Array<number>;
        private parentMesh;
        tempColor: Color;
        constructor(name: string);
        updateUVs(): void;
        getParentMesh(): MeshAttachment;
        setParentMesh(parentMesh: MeshAttachment): void;
        copy(): Attachment;
        newLinkedMesh(): MeshAttachment;
    }
}
declare module spine {
    class PathAttachment extends VertexAttachment {
        lengths: Array<number>;
        closed: boolean;
        constantSpeed: boolean;
        color: Color;
        constructor(name: string);
        copy(): Attachment;
    }
}
declare module spine {
    class PointAttachment extends VertexAttachment {
        x: number;
        y: number;
        rotation: number;
        color: Color;
        constructor(name: string);
        computeWorldPosition(bone: Bone, point: Vector2): Vector2;
        computeWorldRotation(bone: Bone): number;
        copy(): Attachment;
    }
}
declare module spine {
    class RegionAttachment extends Attachment {
        x: number;
        y: number;
        scaleX: number;
        scaleY: number;
        rotation: number;
        width: number;
        height: number;
        color: Color;
        path: string;
        rendererObject: any;
        region: TextureRegion;
        offset: ArrayLike<number>;
        uvs: ArrayLike<number>;
        tempColor: Color;
        constructor(name: string);
        updateOffset(): void;
        setRegion(region: TextureRegion): void;
        computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
        copy(): Attachment;
        static X1: number;
        static Y1: number;
        static C1R: number;
        static C1G: number;
        static C1B: number;
        static C1A: number;
        static U1: number;
        static V1: number;
        static X2: number;
        static Y2: number;
        static C2R: number;
        static C2G: number;
        static C2B: number;
        static C2A: number;
        static U2: number;
        static V2: number;
        static X3: number;
        static Y3: number;
        static C3R: number;
        static C3G: number;
        static C3B: number;
        static C3A: number;
        static U3: number;
        static V3: number;
        static X4: number;
        static Y4: number;
        static C4R: number;
        static C4G: number;
        static C4B: number;
        static C4A: number;
        static U4: number;
        static V4: number;
    }
}
declare module spine {
    class JitterEffect implements VertexEffect {
        jitterX: number;
        jitterY: number;
        constructor(jitterX: number, jitterY: number);
        begin(skeleton: Skeleton): void;
        transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
        end(): void;
    }
}
declare module spine {
    class SwirlEffect implements VertexEffect {
        static interpolation: PowOut;
        centerX: number;
        centerY: number;
        radius: number;
        angle: number;
        private worldX;
        private worldY;
        constructor(radius: number);
        begin(skeleton: Skeleton): void;
        transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
        end(): void;
    }
}


Streetmap, the online UK map service, is to launch a pocket service that covers the whole of Europe, with driving directions and links to GPS systems, for 50 euros per year. The service will be followed in September by a static Web version for a smaller subscription.
The subscription-based service will cover the whole of Europe, and will be more detailed than the existing UK map. It will include up-to-date traffic and accident information and local entertainment listings for the UK, according to the company.
The system includes details such as the direction of one-way streets and pedestrian routes, (obviously essential for driving instructions) and any speed limits -- indicated in red.
Maps will be based on information from Navigation Technologies (NavTech), provided as vectors and driving instructions. Streetmap has processed the information to turn the vectors into maps. Tiles are downloaded to the mobile device, cached and displayed when required.
The application was developed using Microsoft's .Net Compact Framework, which delivers applications for Pocket PC and Smartphone devices. It uses Active Templating as well as SOAP and XML, and can be exported to other applications as an ActiveX or other control.
Future versions will add a module for spoken directions, so drivers can use it while they keep their eyes on the road. The speech synthesis will be done by 20/20 Speech.
In September, Streetmap will launch a cheaper version for destktop systems, without the scrolling. Pricing was not released yet but "will be attractive", said Sutton. Users will be limited to 500 maps per year, but this should be plenty, she said, as most current users of the free site, average 108 maps per year.
Surprisingly, Streetmap consists of only two people, though Sutton says that at any given time they may be employeeing up to 50 freelancers working on tasks such as producing maps. It has also reached this position without any venture capital funding.
Streetmap, whose free Web site has been a runaway success for creators Kate Sutton and Penny Bamborough, currently delivers map information for the whole of the UK, searchable by map reference, street name or postcode. Turning over £250,00 per year, the six-year-old site is profitable.
"We set it up as something useful to put on the Web," said Sutton, at Microsoft's Tech Ed exhibition in Barcelona. "It began as a well-funded hobby, delivering London street information (from publisher Bartholomews) over a 64kbps leased line. The site now requires a £14,000 managed network service, and both women have left their former jobs to work on it full-time. The current service includes map information from Ordnance Survey as well as aerial photographs, and is funded by advertising.
"It grew and grew. It was viral marketing, but not planned," said Sutton. "You can't plan viral marketing. It either happens or it doesn't."
As part of their international expansion, the two have bought the domain streetmap.com for £157,000. Until recently, this pointed to rival Multimap.


text:
Simon Vinkenoog (1928-2009)
June 13, 2011 February 2, 2020 admin
Allen Ginsberg and Simon Vinkenoog at Musee Rimbaud, Charleville, December 1982. Photo: Joep Bremmers
As Stewart Home pointedly noted, in his review of Wholly Communion (Peter Whitehead and the Sixties) – "Curiously it is Simon Vinkenoog who is featured on the cover of this BFI (British Film Institute) DVD, despite the fact that (his) Vinkenoog's on-stage performance at the Albert Hall was not recorded by Whitehead". Indeed, Whitehead (in an interview with film scholar, Jack Sargeant) takes it one step further, professing to have no memory whatsoever of there ever even having been such a performance. What is captured – and has remained indelibly memorable, however – is Vinkenoog, in the audience, high on mescaline, interrupting the frail figure of poet Harry Fainlight reading – it was, very much, a drug-influenced night that night – Fainlight was reading his quintessential LSD poem, "The Spider".
As Whitehead recalls:
"Harry was waxing lyrical in the middle of recreating his LSD trip, and suddenly this howl came from somewhere – we didn't know where – someone was shouting. I didn't even know what the sound was, finally I figured it out that it was "love" that he (Simon) was shouting: "Looovvve! Looovvve!" you see. He's shouting "love", but, number one, he is Dutch, number two he's on mescaline. And this interrupts Harry's poem, and of course he finds it then very difficult to get started again. Harry turns around and accuses Simon, who was a friend, "You're a lovable idiot".."
This key moment should illuminate this – a copy of Vinkenoog's Plutonische Ode (Plutonian Ode) in a bi-lingual (Dutch-English) edition – "signed by Vinkenoog, who has also written the word "Love" three times across the rear endpaper and inside of the rear wrap". Simon was, and remained, Allen's esteemed Dutch translator.
Jap van der Bent in his groundbreaking essay, "O fellow travelers I write you a poem in Amsterdam – Allen Ginsberg, Simon Vinkenoog and the Dutch Beat Connection" :
"Strangely enough neither of the Ginsberg biographies which have been published to date [he's writing in the year 2000] pays much attention to the artistic and personal relationship between the Dutch and American poet, even though the two met not only in 1957 and 1967 but also during Ginsberg's visits to Holland in the 1970s and 1980s. On each of these visits Vinkenoog served as Ginsberg's translator, after having published the first, and still the only, substantial Dutch translation of Ginsberg's poems, "Proef m'n tong in je oor" (Taste my mouth in your ear), (1966). [he also published the book-length collection, "Me and my peepee" (translations of Allen) in 2001] It was also during one of those visits that Ginsberg found the inspiration for his poem, "What The Sea Throws Up at Vlissingen", published in White Shroud: Poems 1980-1985 (1986) and dedicated to Vinkenoog."
In 1982 Vinkenoog famously accompanied Allen to Arthur Rimbaud's birthplace in Charleville. Joep Bremmers has been engaged in annotating and footnoting Allen's notebooks from this period (some of which may be accessed here ).
Simon was European Beat personnified, "poet, activist, lifelong hippy, and [not incidentally] cannabis connoisseur par excellence ",he, as this short but succinct biographical note points out, "never seemed to go out of style and was regularly rediscovered by new generations of poets and performance artists". He wrote and published extensively (his 1972 anthology with George Andrews, The Book of Grass , might, perhaps, be singled out, but that was just one of many, of a host of titles; he wrote novels, biography, journalism, as well as singularly influential translation). As an anthologist, his 1950 anthology, Atonaal (Atonal) launched an important movement, the " Fifties Movement " in Dutch poetry. Towards the end of his life, in 2004, he was chosen as "Dichter des Vaderlands" (Poet Laureate) for the Netherlands. On his death, in July 2009, an international community mourned. Even Dutch Queen Beatrix sent her condolences, from her summer residence in Italy, stating "With this man the world has lost a unique writer".
His web-site (posthumous tho' it may be) is a veritable trove and well worth examining. Among the treasures therein, we select this. Ever the optimist, this is how Simon faced the world:
Beat History
Harry Fainlight
Joep Bremmers
Previous Wholly Communion – Peter Whitehead (ASV5)
Next Alex Trocchi (1925-1984)


text:
Kirklees Magistrates Court
Jasjeet Heer exposed himself to a mum watching her child play in the garden
Bradley man Jasjeet Heer admitted exposing himself to two women
Emma Davison
Jasjeet Heer of Bent Lea, Bradley
A man who exposed his penis to two of his neighbours has been ordered to register as a sex offender for the next five years.
One of the victims was particularly distressed by Jasjeet Heer's behaviour as her young son was playing in the garden at the time.
The other was approached by the 30-year-old as she was gardening at her Bradley home.
Heer pleaded guilty to two charges of indecent exposure when he appeared at Kirklees Magistrates' Court.
The women reported the incidents on June 1 to a builder working on Bradley Road, prosecutor Alex Bozman said.
One of the victims was working in her front garden when she was approached by Heer, who lives nearby in Bent Lea.
Mr Bozman said: "He claimed that he was looking for a particular house then came closer to her as she was gardening.
"Then he pulled his underwear and shorts down to expose his genitals."
The woman said that the whole incident lasted for around five minutes and she's never seen Heer before.
The other victim was at home watching her son playing outside with his friends.
Mr Bozman said: "She saw the defendant from her kitchen window, looking directly at her and exposing his penis to her before walking off down the road."
Magistrates heard that the mum made contact with the same builder who had been told about the earlier incident.
Mr Bozman added: "She was very disturbed because the male approached her and was in her garden trying the door.
"Because of this she doesn't want her children playing out of her view.
"It's concerning because he lives in very close proximity to these two parties."
Heer was arrested and initially claimed that he was doing stretches.
His solicitor Fazaila Kauser explained that he suffers from Asperger's syndrome and lives an isolated life.
She said: "He understands that his conduct caused alarm and distress to the two ladies when he exposed his penis.
"He's sorry and remorseful for his actions but does need some support."
Magistrates ordered Heer to sign the sex offenders' register for five years.
He must complete a 12-month community order with 20 days of activities.
Finally, he has to pay £50 compensation to each victim as well as £85 costs and £85 victim surcharge.


For so long I was silenced but NO MORE. I'm no longer scared, embarrassed, or pushed down. I am strong, courageous, and beautiful.I am not a product of my past but a solution to my future. I rise above the pain and show love by example.
I have risen because I am empowered to do so. And that tomb that tried to smother me, make me claustrophobic, keep my soul in the dark…. No more!
I am a strong and a mighty woman and my experiences, my truth is what sets me free.
I have nothing more to lose.
I hope by reading my blogs, my life, my stories.. You too can set yourself free!
Note: Images on my blog are courtesy of Pixabay and my personal photos. Any other image without a watermark are public use.


This license shall automatically terminate if you violate any of these restrictions and may be terminated by Cloudware Information Logistics at any time. Upon terminating your viewing of these materials or upon the termination of this license, you must destroy any downloaded materials in your possession whether in electronic or printed format.
The materials on Cloudware Information Logistics web site are provided "as is". Cloudware Information Logistics makes no warranties, expressed or implied, and hereby disclaims and negates all other warranties, including without limitation, implied warranties or conditions of merchantability, fitness for a particular purpose, or non-infringement of intellectual property or other violation of rights. Further, Cloudware Information Logistics does not warrant or make any representations concerning the accuracy, likely results, or reliability of the use of the materials on its Internet web site or otherwise relating to such materials or on any sites linked to this site.
In no event shall Cloudware Information Logistics or its suppliers be liable for any damages (including, without limitation, damages for loss of data or profit, or due to business interruption,) arising out of the use or inability to use the materials on Cloudware Information Logistics Internet site, even if Cloudware Information Logistics or a Cloudware Information Logistics authorized representative has been notified orally or in writing of the possibility of such damage. Because some jurisdictions do not allow limitations on implied warranties, or limitations of liability for consequential or incidental damages, these limitations may not apply to you.
The materials appearing on Cloudware Information Logistics web site could include technical, typographical, or photographic errors. Cloudware Information Logistics does not warrant that any of the materials on its web site are accurate, complete, or current. Cloudware Information Logistics may make changes to the materials contained on its web site at any time without notice. Cloudware Information Logistics does not, however, make any commitment to update the materials.
Cloudware Information Logistics has not reviewed all of the sites linked to its Internet web site and is not responsible for the contents of any such linked site. The inclusion of any link does not imply endorsement by Cloudware Information Logistics of the site. Use of any such linked web site is at the user's own risk.
Any claim relating to Cloudware Information Logistics web site shall be governed by the laws of the State of Missouri without regard to its conflict of law provisions.
This is a legal agreement between you and Cloudware Information Logistics(operated by NetWare Hosting, Inc.), a Missouri corporation ("NWH") and governs your use of the Smooth DispatchTM software and mobile application, including without limitation, any new release, update, supplement or replacement (individually and collectively, the "Application") and any reference materials or technical documentation related to the Application ("Application Documentation").
The Application, Application Documentation and any services, including support or maintenance services, provided through the Application (collectively, the "Services") are licensed, not sold, to you for use only under the terms of this License.
Section 2 below governs the information and data collected from you through the Application and its registration process.
If you do not agree to Section 2, do not register for or use this Application.
Through the use of the Application, you are acquiring, and NWH grants you, a personal, limited, non-exclusive, non-sublicensable, non-transferable license to use the Application on a computer or mobile device only for internal business purposes and in accordance with the terms and conditions of this License.
You may not use the Application for any purpose, or in any manner not specifically authorized by this License. You shall not alter or remove from any copies or partial copies of the Application or Application Documentation any copyright, trademark or other proprietary notice, or license terms where and as found in the Application as delivered to You. You may not disassemble, reverse engineer, decrypt, decompile, create derivative works from, or translate the Application, or any portion thereof, or recreate or attempt to recreate the Application, in whole or in part by reference to the Application, or perform any process intended to determine the source code for the Application except to the extent that the foregoing restriction is prohibited by applicable law; nor shall You sublicense, distribute, deliver, disclose or otherwise provide to a third party any Application or portion thereof, including without limitation, any account or password information associated with Your access to the Application. Any unauthorized attempt to assign, sublicense or grant other rights to the Application shall be immediately and automatically void. You shall not share or disclose your login credentials (including username and password) with any other person or third party, nor shall you allow any other person or third party to access the Application through your account.
You acknowledge and agree that the Application (including the software and mobile application and all methods, concepts or techniques utilized therein) and related documentation are commercially valuable to NWH, and its licensor or suppliers as the case may be, and are treated as confidential, proprietary and containing of trade secrets. You acknowledge and agree that NWH, and its licensors or suppliers as the case may be, owns all right, title and interest in and to the Application and any intellectual property rights therein and associated therewith, including without limitation any patents, trademarks, trade names, inventions, copyrights, know-how, and trade secrets relating to the design, manufacture, operation, or service of the Application and all derivatives, modifications, translations, or extensions thereof.
You recognize that nothing contained in this License is intended to assign or grant to you any right, title or interest in or to the Application or any associated intellectual property. Your use of the Application is authorized only for the purposes herein set forth. Your use of the Application shall cease immediately upon termination of this License for any reason. All rights not expressly granted herein are reserved by NWH.
To the extent you make any contributions in any form or format through your use of the Application, you hereby grant NWH perpetual, worldwide, non-exclusive, royalty-free, irrevocable, fully transferable and assignable, fully sublicensable right and license to use modify any ideas, concepts developments, modifications and information arising out of your contributions in any way and for any purpose in connection with the Application and related services including the rights to reproduce, copy, adapt, modify, change, revise, further develop, perform, display, publish, broadcast, transmit and distribute your contributions without any further notice or compensation to you of any kind for the whole duration of protection granted to intellectual property rights by applicable laws and international conventions as authorized by this License. You hereby waive any and all moral rights you may have in such contributions with respect to NWH use and further waive all rights in the contributions under the Visual Artists Rights Act.
You or your employer, as applicable, shall maintain complete ownership of all End User Data (defined below) loaded, input or hosted by or via the Application. On behalf of yourself and your employer, you hereby grant NWH a worldwide, non-exclusive, sublicensable, royalty-free license to use, host, translate, publish, distribute, reformat, remove and prepare derivative works of the End User Data for the purposes of revising, modifying, evolving, training, improving, optimizing and further developing the algorithms and data included in the Application and providing such End User Data to vendors, brokers, customers and other third parties involved in contracting or coordinating deliveries, orders or other transactions to which such End User Data relates. "End User Data" shall mean any and all data, order information, delivery documents, proofs of delivery (POD), delivery receipts, scale tickets, bills of lading, invoices, purchase orders, shipping forms, and other documentation relating to the shipping, hauling or transportation of goods, products and materials, contracts, images, notes, descriptions, reports, and other information loaded or input into or via the Application by you.
Use of the Application may require Internet access. You must provide at your own expense the computer, equipment, Internet connection, devices and/or service or wireless plan to access and use the Application. NWH does not guarantee that the Application can be accessed on all computers, browsers, devices, Internet connections or wireless service plans. NWH does not guarantee that the Application is available in all geographic locations. You acknowledge that when you use this Application via a smartphone or other wireless or cellular device, your wireless carrier may charge you fees for data, Internet usage, messaging and/or other wireless access. Check with your carrier to see if there are any such fees that apply to you. You are solely responsible for any costs you incur to access the Application from your computer and other device(s).
By registering for and accessing the Application, you represent that you are at least eighteen (18) years old. NWH reserves the right to terminate your access to the Application or your account for any reason, including if we have reasonable grounds to suspect that you have provided information that that is inaccurate. Additionally, any user name or login you use or create as part of the Application shall not violate any third party's rights or be harassing, libelous, defamatory, abusive, tortious, threatening, harmful obscene, indecent, libelous, threatening, harassing, hateful, containing bigotry, racism or is otherwise objectionable. NWH, in its sole discretion, shall have the right to remove any user name or login which it finds to be objectionable. Further, you agree not to engage in any activity that in any way disrupts, limits, destroys or manipulates the Application, or any software, hardware, servers, networks, or other equipment.
Through the Application and its registration process, we may collect information such as your name, phone number, email address, physical address and employer information, and require you to create a username login and password.
NWH treats all personal data as Confidential Information (defined below) and will maintain such personal data in confidence and prevent its unauthorized use or disclosure as set forth in Section 8 of this License. Notwithstanding the foregoing, NWH may, and you hereby authorize NWH to, use your personal data in order to provide you the Services and enable you to use the Application. In accordance with the foregoing, you hereby grant NWH a worldwide, non-exclusive, non-sublicensable, non-transferable, royalty-free license to use, host, translate, reformat, remove and prepare derivative works of your personal data for the purposes of providing you the Application and the Services in accordance with this Section.
NWH may use you non-personal data, including End User Data as defined in Section 1(e), for the purpose of providing, improving and enhancing the Application and the Services. In accordance with the foregoing, you hereby grant NWH a worldwide, non-exclusive, non-sublicensable, non-transferable, royalty-free license to use, host, translate, reformat, remove and prepare derivative works of the non-personal data, including End User Data, for purposes of operating the Application, providing the Services and revising, modifying, evolving, training, improving, optimizing and further developing the algorithms and data included in the Application and Services. You represent and warrant that (i) you have sufficient right, title and interest to upload and input the End User Data into or via the Application and to grant NWH the licenses for the non-personal data, including End User Data, provided herein without the consent of any third party, (ii) NWH's use of the End User Data for purposes of operating the Application and providing Services under this License will not require a license from any third party, (iii) the End User Data will not violate any third party intellectual property rights, and (iv) the End User Data will be free from any viruses, worms, disabling programming codes, locks, clocks, counters, timers, time bombs, instructions, easter eggs or other such items that may threaten, infect, damage, disable or otherwise interfere with the Application or the hardware, servers and other computer systems of NWH or any third party hosting provider.
This License is effective until terminated by NWH or you. This License shall automatically terminate without notice to you (a) upon the termination of a master license agreement under which this License is provided, or (b) if you fail to comply with any of the terms or conditions of this License. Upon termination, you shall cease all use of the Application and uninstall the Application from all computers and device(s) upon which it is installed. The following Sections shall survive termination of this License: Sections 1(b), 1(c), 1(d), 1(e), 2(b), 2(c), 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 and 15.
Third Party Materials and Sites.
The Application may display, include or make available content, advertisements, data, information, applications and other materials from third parties ("Third Party Materials") or provide links to certain third party web sites or applications. You acknowledge and agree that NWH is not responsible for examining or evaluating the content, accuracy, completeness, timeliness, validity, copyright compliance, legality, decency, quality or any other aspect of such Third Party Materials or third party web sites or applications. NWH does not warrant or endorse and does not assume and will not have any liability or responsibility to you or any other person for any Third Party Materials or third party web sites or applications, or for any other materials, products, or services of third parties.
Third Party Terms and Conditions.
Your access and use of the Application and Third Party Materials may be subject to certain third party terms and conditions and privacy policies, including but not limited to those of application stores, mobile software platforms and wireless carriers and providers. You acknowledge and agree that NWH is not liable for any such third party terms and conditions.
YOUR USE OF THE APPLICATION IS AT YOUR OWN RISK. THE APPLICATION AND ANY INFORMATION AND SERVICES OFFERED ON OR THROUGH THE APPLICATION AND ANY REFERENCED THIRD-PARTY MATERIALS, WEB SITES AND APPLICATIONS ARE PROVIDED TO YOU "AS IS" AND ARE PROVIDED WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED. NWH DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES TO THE FULLEST EXTENT OF THE LAW, INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTY OF MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. NWH DOES NOT WARRANT THAT THE APPLICATION WILL MEET ALL OF YOUR REQUIREMENTS OR THAT USE OF THE APPLICATION WILL BE UNINTERRUPTED OR ERROR-FREE. ANY THIRD PARTY MATERIALS OR WEB SITES NWH PROVIDES ARE PROVIDED AS A CONVENIENCE TO YOU AND NWH'S PROVISION OF THESE THIRD PARTY MATERIALS OR WEB SITES DOES NOT CONSTITUTE SPONSORSHIP, AFFILIATION, PARTNERSHIP, OR ENDORSEMENT. NWH DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OR THE RESULTS OF THE APPLICATION OR THE MATERIAL PROVIDED THROUGH THE APPLICATION IN TERMS OF CORRECTNESS, ACCURACY, TIMELINESS, RELIABILITY OR OTHERWISE.
You agree to indemnify, defend and hold harmless NWH and its directors, officers, affiliates, employees, agents, representatives, third party service providers, successors and assigns (each an "Indemnitee") from and against any and all claims, damages, losses and expenses suffered or incurred by any such Indemnitee arising from, relating to or otherwise in respect of any loss, damage or to any person or property resulting from or relating to your use of the Application or any breach of this License, including but not limited to, any breach of a representation and warranty made herein.
TO THE FULLEST EXTENT PERMISSIBLE BY LAW, In no event shall NWH be liable for loss of profits, LOSS OF DATA, LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER OR DEVICE FAILURE OR MALFUNCTION, SUBSTITUTE GOODS OR SERVICES or ANY OTHER DIRECT, indirect, special, incidental, or consequential damages arising out of or related to THIS LICENSE OR THE APPLICATION, WHETHER ARISING IN TORT (INCLUDING NEGLIGENCE), CONTRACT, STRICT LIABILITY OR OTHERWISE. Furthermore, ANY OTHER damages recoverable by YOU from NWH shall in no case exceed THE AMOUNT ACTUALLY PAID BY YOU FOR THE APPLICATION.
Each party acknowledges and accepts the responsibility to maintain all Confidential Information (defined below) of the other party in confidence and to prevent its unauthorized use or disclosure, using measures the receiving party uses to protect its own similar confidential information, but in any event, no less than a reasonable degree of care. Without limiting the foregoing, each party agrees that it shall not publish, disclose or otherwise provide to any person (except employees or contractors with a legitimate need to know and who have entered into a written agreement with the receiving party containing confidentiality provisions as restrictive as those set forth in this Section 8), or use for any purpose other than those purposes contemplated by this License, any Confidential Information it receives hereunder. Notwithstanding the foregoing, you acknowledge that certain End User Data and location information may be made accessible by NWH to vendors, brokers, customers or other third parties involved in contracting or coordinating deliveries, orders or other transactions to which such End User Data and location information relates. To the extent the receiving party is required by subpoena or otherwise by law to disclose Confidential Information it received from the disclosing party, the receiving party shall provide the disclosing party with prompt written notice of such requirement and shall cooperate with the disclosing party in taking such steps as may be reasonably indicated to maintain the confidentiality of the information subject to disclosure. Each party acknowledges that violations of the terms hereof may cause the other immediate and irreparable damage for which monetary damages may be inadequate for which the other party is entitled to seek injunctive relief.
"Confidential Information" shall mean any and all information and documentation relating directly or indirectly to the business, business practices, trade secrets or affairs of a party, including but not limited to, that pertaining to (a) the internal business, financial and marketing information of either party; (b) the software code and its technical documentation (including, without limitation, the architecture, conceptual logic, know-how and other intellectual property embodied in the Application and/or Application Documentation, and made accessible to you hereunder); (c) Application user and training documentation; (d) End User Data; (e) the contractual terms, fees and pricing set forth in this License and the discussions, negotiations and proposals related to this License; or (f) any other material or information received from the other party and which is designated as "confidential" or "proprietary", or which are known, or under the circumstances surrounding disclosure reasonably should be known, as the confidential or proprietary material of the disclosing party. Confidential Information shall not include information that (1) was in the receiving party's possession at the time it was received from the disclosing party, (2) is or becomes a matter of public knowledge through no wrongdoing of the receiving party, (3) is rightfully provided to the receiving party by a third party without restrictions of confidentiality, or (4) is independently developed by the receiving party without breach of this License.
You may not use or otherwise export or re-export the Application except as authorized by United States law and the laws of the jurisdiction in which the Application was obtained. In particular, but without limitation, the Application may not be exported or re-exported (a) into any U.S. embargoed countries or (b) to anyone on the U.S. Treasury Department's list of Specially Designated Nationals or the U.S. Department of Commerce Denied Person's List or Entity List. By using the Application, you represent and warrant that you are not located in any such country or on any such list. You also agree that you will not use the Application for any purposes prohibited by United States or foreign law.
You agree that a breach of this License will cause irreparable injury to NWH for which monetary damages would not be an adequate remedy and NWH shall be entitled to seek equitable relief in addition to any remedies it may have hereunder or at law without a bond, security or proof of damages.
This License constitutes the entire agreement between you and NWH with respect to the Application and supersedes all prior negotiations, discussions or representations, whether written or oral.
NWH may assign this License without notice to you. You shall not assign this License without the prior written consent of NWH. Such consent may be withheld at NWH's sold discretion.
This License shall be construed in accordance with Missouri law without giving effect to the choice or conflicts of law provisions thereof. The parties agree that any legal proceedings which arise under this License shall be brought in the 16th Judicial District Court of Jackson County, Missouri, or, if applicable, the United States District Court for the Western District of Missouri.
If any provision of this License is held to be unenforceable in mediation or by a court of competent jurisdiction, the remaining provisions of this License will remain in effect, to be construed as if the unenforceable provision was originally deleted and to be further construed in such a manner as to give effect to the intent of the parties to the greatest extent possible.