text:
var __extends = (this && this.__extends) || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var core_1 = require('angular2/core');
var instrumentation_1 = require('angular2/instrumentation');
var ion_1 = require('../ion');
var nav_params_1 = require('./nav-params');
var util_1 = require('../../util/util');
var swipe_back_1 = require('./swipe-back');
var transition_1 = require('../../transitions/transition');
var view_controller_1 = require('./view-controller');
/**
 * @name NavController
 * @description
 * _For examples on the basic usage of NavController, check out the
 * [Navigation section](../../../../components/#navigation) of the Component
 * docs._
 *
 * NavController is the base class for navigation controller components like
 * [`Nav`](../Nav/) and [`Tab`](../../Tabs/Tab/). You use navigation controllers
 * to navigate to [pages](#creating_pages) in your app. At a basic level, a
 * navigation controller is an array of pages representing a particular history
 * (of a Tab for example). This array can be manipulated to navigate throughout
 * an app by pushing and popping pages or inserting and removing them at
 * arbitrary locations in history.
 *
 * The current page is the last one in the array, or the top of the stack if we
 * think of it that way.  [Pushing](#push) a new page onto the top of the
 * navigation stack causes the new page to be animated in, while [popping](#pop)
 * the current page will navigate to the previous page in the stack.
 *
 * Unless you are using a directive like [NavPush](../NavPush/), or need a
 * specific NavController, most times you will inject and use a reference to the
 * nearest NavController to manipulate the navigation stack.
 *
 *
Injecting NavController

 * Injecting NavController will always get you an instance of the nearest
 * NavController, regardless of whether it is a Tab or a Nav.
 *
 * Behind the scenes, when Ionic instantiates a new NavController, it creates an
 * injector with NavController bound to that instance (usually either a Nav or
 * Tab) and adds the injector to its own providers.  For more information on
 * providers and dependency injection, see [Providers and DI]().
 *
 * Instead, you can inject NavController and know that it is the correct
 * navigation controller for most situations (for more advanced situations, see
 * [Menu](../../Menu/Menu/) and [Tab](../../Tab/Tab/)).
 *
 * ```ts
 *  class MyComponent {
 *    constructor(nav: NavController) {
 *      this.nav = nav;
 *    }
 *  }
 * ```
 *
 *
Page creation

 * _For more information on the `@Page` decorator see the [@Page API
 * reference](../../../decorators/Page/)._
 *
 * Pages are created when they are added to the navigation stack.  For methods
 * like [push()](#push), the NavController takes any component class that is
 * decorated with `@Page` as its first argument.  The NavController then
 * compiles that component, adds it to the app and animates it into view.
 *
 * By default, pages are cached and left in the DOM if they are navigated away
 * from but still in the navigation stack (the exiting page on a `push()` for
 * example).  They are destroyed when removed from the navigation stack (on
 * [pop()](#pop) or [setRoot()](#setRoot)).
 *
 *
 *
Lifecycle events

 * Lifecycle events are fired during various stages of navigation.  They can be
 * defined in any `@Page` decorated component class.
 *
 * ```ts
 * @Page({
 *   template: 'Hello World'
 * })
 * class HelloWorld {
 *   onPageLoaded() {
 *     console.log("I'm alive!");
 *   }
 *   onPageWillLeave() {
 *     console.log("Looks like I'm about to leave :(");
 *   }
 * }
 * ```
 *
 *
 *
 * - `onPageLoaded` - Runs when the page has loaded. This event only happens once per page being created and added to the DOM. If a page leaves but is cached, then this event will not fire again on a subsequent viewing. The `onPageLoaded` event is good place to put your setup code for the page.
 * - `onPageWillEnter` - Runs when the page is about to enter and become the active page.
 * - `onPageDidEnter` - Runs when the page has fully entered and is now the active page. This event will fire, whether it was the first load or a cached page.
 * - `onPageWillLeave` - Runs when the page is about to leave and no longer be the active page.
 * - `onPageDidLeave` - Runs when the page has finished leaving and is no longer the active page.
 * - `onPageWillUnload` - Runs when the page is about to be destroyed and have its elements removed.
 * - `onPageDidUnload` - Runs after the page has been destroyed and its elements have been removed.
 *
 * @see {@link /docs/v2/components#navigation Navigation Component Docs}
 */
var NavController = (function (_super) {
    __extends(NavController, _super);
    function NavController(parent, _app, config, _keyboard, elementRef, _anchorName, _compiler, _viewManager, _zone, _renderer) {
        _super.call(this, elementRef);
        this._app = _app;
        this._keyboard = _keyboard;
        this._anchorName = _anchorName;
        this._compiler = _compiler;
        this._viewManager = _viewManager;
        this._zone = _zone;
        this._renderer = _renderer;
        this._transIds = 0;
        this._init = false;
        this._ids = -1;
        this._trnsTime = 0;
        this._views = [];
        this.parent = parent;
        this.config = config;
        this._trnsDelay = config.get('pageTransitionDelay');
        this._sbEnabled = config.getBoolean('swipeBackEnabled') || false;
        this._sbThreshold = config.get('swipeBackThreshold') || 40;
        this.id = ++ctrlIds;
        // build a new injector for child ViewControllers to use
        this.providers = core_1.Injector.resolve([
            core_1.provide(NavController, { useValue: this })
        ]);
    }
    /**
     * Set the root for the current navigation stack
     * @param {Type} page  The name of the component you want to push on the navigation stack
     * @param {object} [params={}] Any nav-params you want to pass along to the next view
     * @param {object} [opts={}] Any options you want to use pass to transtion
     * @returns {Promise} Returns a promise when done
     */
    NavController.prototype.setRoot = function (page, params, opts) {
        if (params === void 0) { params = {}; }
        if (opts === void 0) { opts = {}; }
        return this.setPages([{ page: page, params: params }], opts);
    };
    /**
     * You can set the views of the current navigation stack and navigate to the last view past
     *
     *
     *```typescript
     * import {Page, NavController} from 'ionic/ionic'
     * import {Detail} from '../detail/detail'
     * import {Info} from '../info/info'
     *
     *  export class Home {
     *    constructor(nav: NavController) {
     *      this.nav = nav;
     *    }
     *    setPages() {
     *      this.nav.setPages([ {page: List}, {page: Detail}, {page:Info} ]);
     *    }
     *  }
     *```
     *
     *
     *In this example, we're giving the current nav stack an array of pages. Then the navigation stack will navigate to the last view in the array and remove the orignal view you came from.
     *
     * By default, animations are disabled, but they can be enabled by passing options to the navigation controller
     *
     *
     *```typescript
     * import {Page, NavController} from 'ionic/ionic'
     * import {Detail} from '../detail/detail'
     *
     *  export class Home {
     *    constructor(nav: NavController) {
     *      this.nav = nav;
     *    }
     *    setPages() {
     *      this.nav.setPages([ {page: List}, {page: Detail} ], {
     *        animate: true
     *      });
     *    }
     *  }
     *```
     *
     *
     *You can also pass any navigation params to the individual pages in the array.
     *
     *
     *```typescript
     * import {Page, NavController} from 'ionic/ionic';
     * import {Info} from '../info/info';
     * import {List} from '../list/list';
     * import {Detail} from '../detail/detail';
     *
     *  export class Home {
     *    constructor(nav: NavController) {
     *      this.nav = nav;
     *    }
     *    setPages() {
     *      this.nav.setPages([{
     *        page: Info
     *      }, {
     *        page: List,
     *        params: {tags: 'css'}
     *      }, {
     *        page: Detail,
     *        params: {id: 325}
     *      }]);
     *    }
     *  }
     *```
     *
     * @param {array<Type>} pages  An arry of page components and their params to load in the stack
     * @param {object} [opts={}] Any options you want to use pass
     * @returns {Promise} Returns a promise when the pages are set
     */
    NavController.prototype.setPages = function (pages, opts) {
        if (opts === void 0) { opts = {}; }
        if (!pages || !pages.length) {
            return Promise.resolve(false);
        }
        // deprecated warning
        pages.forEach(function (pg) {
            if (pg['componentType']) {
                pg.page = pg['componentType'];
                void 0;
            }
            else if (!pg['page']) {
                void 0;
            }
        });
        // remove existing views
        var leavingView = this._remove(0, this._views.length);
        // create view controllers out of the pages and insert the new views
        var views = pages.map(function (p) { return new view_controller_1.ViewController(p.page, p.params); });
        var enteringView = this._insert(0, views);
        // if animation wasn't set to true then default it to NOT animate
        if (opts.animate !== true) {
            opts.animate = false;
        }
        // set the nav direction to "back" if it wasn't set
        opts.direction = opts.direction || 'back';
        var resolve;
        var promise = new Promise(function (res) { resolve = res; });
        // start the transition, fire resolve when done...
        this._transition(enteringView, leavingView, opts, function (hasCompleted) {
            // transition has completed!!
            resolve(hasCompleted);
        });
        return promise;
    };
    /**
     * @private
     */
    NavController.prototype.setViews = function (components, opts) {
        if (opts === void 0) { opts = {}; }
        void 0;
        return this.setPages(components, opts);
    };
    /**
     * Push is how we can pass components and navigate to them. We push the component we want to navigate to on to the navigation stack.
     *
     * ```typescript
     * class MyClass{
     *    constructor(nav:NavController){
     *      this.nav = nav;
     *    }
     *
     *    pushPage(){
     *      this.nav.push(SecondView);
     *    }
     * }
     * ```
     *
     * We can also pass along parameters to the next view, such as data that we have on the current view. This is a similar concept to to V1 apps with `$stateParams`.
     *
     * ```typescript
     * class MyClass{
     *    constructor(nav:NavController){
     *      this.nav = nav;
     *    }
     *
     *    pushPage(user){
     *      this.nav.push(SecondView,{
     *       // user is an object we have in our view
     *       // typically this comes from an ngFor or some array
     *       // here we can create an object with a property of
     *       // paramUser, and set it's value to the user object we passed in
     *       paramUser: user
     *      });
     *    }
     * }
     * ```
     *
     * We'll look at how we can access that data in the `SecondView` in the navParam docs
     *
     * We can also pass any options to the transtion from that same method
     *
     * ```typescript
     * class MyClass{
     *    constructor(nav: NavController){
     *      this.nav = nav;
     *    }
     *
     *    pushPage(user){
     *      this.nav.push(SecondView,{
     *       // user is an object we have in our view
     *       // typically this comes from an ngFor or some array
     *       // here we can create an object with a property of
     *       // paramUser, and set it's value to the user object we passed in
     *       paramUser: user
     *      },{
     *       // here we can configure things like the animations direction or
     *       // or if the view should animate at all.
     *       direction: 'back'
     *      });
     *    }
     * }
     * ```
     * @param {Type} page  The page component class you want to push on to the navigation stack
     * @param {object} [params={}] Any nav-params you want to pass along to the next view
     * @param {object} [opts={}] Any options you want to use pass to transtion
     * @returns {Promise} Returns a promise, which resolves when the transition has completed
     */
    NavController.prototype.push = function (page, params, opts) {
        if (params === void 0) { params = {}; }
        if (opts === void 0) { opts = {}; }
        return this.insertPages(-1, [{ page: page, params: params }], opts);
    };
    /**
     * Present is how we display overlays on top of the content, from within the
     * root level `NavController`. The `present` method is used by overlays, such
     * as `ActionSheet`, `Alert`, and `Modal`. The main difference between `push`
     * and `present`, is that `present` takes a `ViewController` instance, whereas
     * `push` takes a `Page` component class. Additionally, `present` will place
     * the overlay in the root NavController's stack.
     *
     * ```typescript
     * class MyClass{
     *    constructor(nav: NavController) {
     *      this.nav = nav;
     *    }
     *
     *    presentModal() {
     *      let modal = Modal.create(ProfilePage);
     *      this.nav.present(modal);
     *    }
     * }
     * ```
     *
     * @param {ViewController} enteringView The name of the component you want to push on the navigation stack
     * @param {object} [opts={}] Any options you want to use pass to transtion
     * @returns {Promise} Returns a promise, which resolves when the transition has completed
     */
    NavController.prototype.present = function (enteringView, opts) {
        if (opts === void 0) { opts = {}; }
        var rootNav = this.rootNav;
        if (rootNav['_tabs']) {
            // TODO: must have until this goes in
            // https://github.com/angular/angular/issues/5481
            void 0;
            return;
        }
        enteringView.setNav(rootNav);
        opts.keyboardClose = false;
        opts.direction = 'forward';
        if (!opts.animation) {
            opts.animation = enteringView.getTransitionName('forward');
        }
        enteringView.setLeavingOpts({
            keyboardClose: false,
            direction: 'back',
            animation: enteringView.getTransitionName('back')
        });
        // start the transition
        return rootNav._insertViews(-1, [enteringView], opts);
    };
    /**
     * Inserts a view into the nav stack at the specified index.
     * This is useful if you need to add a view at any point in your navigation stack
     *
     * ```typescript
     * export class Detail {
     *    constructor(nav: NavController) {
     *      this.nav = nav;
     *    }
     *    insertPage(){
     *      this.nav.insert(1, Info);
     *    }
     *  }
     * ```
     *
     * This will insert the `Info` page into the second slot of our navigation stack
     *
     * @param {number} insertIndex  The index where you want to insert the page
     * @param {Type} page  The name of the component you want to insert into the nav stack
     * @param {object} [params={}] Any nav-params you want to pass along to the next page
     * @param {object} [opts={}] Any options you want to use pass to transtion
     * @returns {Promise} Returns a promise when the page has been inserted into the navigation stack
     */
    NavController.prototype.insert = function (insertIndex, page, params, opts) {
        if (params === void 0) { params = {}; }
        if (opts === void 0) { opts = {}; }
        return this.insertPages(insertIndex, [{ page: page, params: params }], opts);
    };
    /**
     * Inserts multiple pages into the nav stack at the specified index.
     *
     * ```typescript
     * export class Detail {
     *    constructor(nav: NavController) {
     *      this.nav = nav;
     *    }
     *    insertPages(){
     *      let pages = [
     *        { page: Info },
     *        { page: ProfileList },
     *        { page: ProfileDetail, params: {userId:5} }
     *      ];
     *      this.nav.insertPages(2, pages);
     *    }
     *  }
     * ```
     *
     * This will insert each of the pages in the array, starting at the third slot
     * (second index) of the nav stack. The last page in the array will animate
     * in and become the active page.
     *
     * @param {number} insertIndex  The index where you want to insert the page
     * @param {array<{page: Type, params=: any}>} insertPages  An array of objects, each with a `page` and optionally `params` property
     * @param {object} [opts={}] Any options you want to use pass to transtion
     * @returns {Promise} Returns a promise when the pages have been inserted into the navigation stack
     */
    NavController.prototype.insertPages = function (insertIndex, insertPages, opts) {
        if (opts === void 0) { opts = {}; }
        var views = insertPages.map(function (p) { return new view_controller_1.ViewController(p.page, p.params); });
        return this._insertViews(insertIndex, views, opts);
    };
    NavController.prototype._insertViews = function (insertIndex, insertViews, opts) {
        if (opts === void 0) { opts = {}; }
        if (!insertViews || !insertViews.length) {
            return Promise.reject('invalid pages');
        }
        // insert the new page into the stack
        // returns the newly created entering view
        var enteringView = this._insert(insertIndex, insertViews);
        // set the nav direction to "forward" if it wasn't set
        opts.direction = opts.direction || 'forward';
        // set which animation it should use if it wasn't set yet
        if (!opts.animation) {
            opts.animation = enteringView.getTransitionName(opts.direction);
        }
        var resolve;
        var promise = new Promise(function (res) { resolve = res; });
        // it's possible that the newly added view doesn't need to
        // transition in, but was simply inserted somewhere in the stack
        // go backwards through the stack and find the first active view
        // which could be active or one ready to enter
        for (var i = this._views.length - 1; i >= 0; i--) {
            if (this._views[i].state === STATE_ACTIVE || this._views[i].state === STATE_INIT_ENTER) {
                // found the view at the end of the stack that's either
                // already active or it is about to enter
                if (this._views[i] === enteringView) {
                    // cool, so the last valid view is also our entering view!!
                    // this means we should animate that bad boy in so its the active view
                    // return a promise and resolve when the transition has completed
                    // get the leaving view which the _insert() already set
                    var leavingView = this.getByState(STATE_INIT_LEAVE);
                    // start the transition, fire resolve when done...
                    this._transition(enteringView, leavingView, opts, function (hasCompleted) {
                        // transition has completed!!
                        resolve(hasCompleted);
                    });
                    return promise;
                }
                break;
            }
        }
        // the page was not pushed onto the end of the stack
        // but rather inserted somewhere in the middle or beginning
        // Since there are views after this new one, don't transition in
        // auto resolve cuz there was is no need for an animation
        return Promise.resolve(enteringView);
    };
    /**
     * @private
     */
    NavController.prototype._insert = function (insertIndex, insertViews) {
        // when this is done, there should only be at most
        // 1 STATE_INIT_ENTER and 1 STATE_INIT_LEAVE
        // there should not be any that are STATE_ACTIVE after this is done
        var _this = this;
        // allow -1 to be passed in to auto push it on the end
        // and clean up the index if it's larger then the size of the stack
        if (insertIndex < 0 || insertIndex > this._views.length) {
            insertIndex = this._views.length;
        }
        // first see if there's an active view
        var view = this.getActive();
        if (view) {
            // there's an active view, set that it's initialized to leave
            view.state = STATE_INIT_LEAVE;
        }
        else if (view = this.getByState(STATE_INIT_ENTER)) {
            // oh no, there's already a transition initalized ready to enter!
            // but it actually hasn't entered yet at all so lets
            // just keep it in the array, but not render or animate it in
            view.state = STATE_INACTIVE;
        }
        // insert each of the views in the pages array
        var insertView = null;
        insertViews.forEach(function (view, i) {
            insertView = view;
            // create the new entering view
            view.setNav(_this);
            view.state = STATE_INACTIVE;
            // give this inserted view an ID
            _this._incId(view);
            // insert the entering view into the correct index in the stack
            _this._views.splice(insertIndex + i, 0, view);
        });
        if (insertView) {
            insertView.state = STATE_INIT_ENTER;
        }
        return insertView;
    };
    /**
     * If you wanted to navigate back from a current view, you can use the back-button or programatically call `pop()`
     * Similar to `push()`, you can pass animation options.
     *
     * ```typescript
     * class SecondView{
     *    constructor(nav:NavController){
     *      this.nav = nav;
     *    }
     *    goBack(){
     *      this.nav.pop();
     *    }
     * }
     * ```
     *
     * @param {object} [opts={}] Any options you want to use pass to transtion
     * @returns {Promise} Returns a promise when the transition is completed
     */
    NavController.prototype.pop = function (opts) {
        if (opts === void 0) { opts = {}; }
        // get the index of the active view
        // which will become the view to be leaving
        var activeView = this.getByState(STATE_TRANS_ENTER) ||
            this.getByState(STATE_INIT_ENTER) ||
            this.getActive();
        return this.remove(this.indexOf(activeView), 1, opts);
    };
    /**
     * Similar to `pop()`, this method let's you navigate back to the root of the stack, no matter how many views that is
     * @param {object} [opts={}] Any options you want to use pass to transtion
     */
    NavController.prototype.popToRoot = function (opts) {
        if (opts === void 0) { opts = {}; }
        return this.popTo(this.first(), opts);
    };
    /**
     * Pop to a specific view in the history stack
     * @param {ViewController} view  to pop to
     * @param {object} [opts={}]  Any options you want to use pass to transtion
     */
    NavController.prototype.popTo = function (view, opts) {
        if (opts === void 0) { opts = {}; }
        var startIndex = this.indexOf(view);
        var activeView = this.getByState(STATE_TRANS_ENTER) ||
            this.getByState(STATE_INIT_ENTER) ||
            this.getActive();
        var removeCount = this.indexOf(activeView) - startIndex;
        return this.remove(startIndex + 1, removeCount, opts);
    };
    /**
     * Removes a view from the nav stack at the specified index.
     *
     * ```typescript
     * export class Detail {
     *    constructor(nav: NavController) {
     *      this.nav = nav;
     *    }
     *    removeView(){
     *      this.nav.remove(1);
     *    }
     *  }
     * ```
     *
     * @param {number} [startIndex]  The starting index to remove pages from the stack. Default is the index of the last page.
     * @param {number} [removeCount]  The number of pages to remove, defaults to remove `1`.
     * @param {object} [opts={}] Any options you want to use pass to transtion.
     * @returns {Promise} Returns a promise when the page has been removed.
     */
    NavController.prototype.remove = function (startIndex, removeCount, opts) {
        var _this = this;
        if (startIndex === void 0) { startIndex = -1; }
        if (removeCount === void 0) { removeCount = 1; }
        if (opts === void 0) { opts = {}; }
        if (startIndex === -1) {
            startIndex = this._views.length - 1;
        }
        else if (startIndex < 0 || startIndex >= this._views.length) {
            return Promise.reject("remove index out of range");
        }
        // default the direction to "back"
        opts.direction = opts.direction || 'back';
        // figure out the states of each view in the stack
        var leavingView = this._remove(startIndex, removeCount);
        if (!leavingView) {
            var forcedActive = this.getByState(STATE_FORCE_ACTIVE);
            if (forcedActive) {
                // this scenario happens when a remove is going on
                // during a transition
                var resolve;
                var promise = new Promise(function (res) { resolve = res; });
                if (!opts.animation) {
                    opts.animation = forcedActive.getTransitionName(opts.direction);
                }
                if (this._trans) {
                    this._trans
                        .onFinish(function () {
                        opts.animate = false;
                        _this._transition(forcedActive, null, opts, function (hasCompleted) {
                            // transition has completed!!
                            resolve(hasCompleted);
                        });
                    }, false, true)
                        .stop();
                    this._trans.destroy();
                    this._trans = null;
                }
                else {
                    resolve(false);
                }
                return promise;
            }
        }
        if (leavingView) {
            // there is a view ready to leave, meaning that a transition needs
            // to happen and the previously active view is going to animate out
            var resolve;
            var promise = new Promise(function (res) { resolve = res; });
            if (!opts.animation) {
                opts.animation = leavingView.getTransitionName(opts.direction);
            }
            // get the view thats ready to enter
            var enteringView = this.getByState(STATE_INIT_ENTER);
            // start the transition, fire resolve when done...
            this._transition(enteringView, leavingView, opts, function (hasCompleted) {
                // transition has completed!!
                resolve(hasCompleted);
            });
            return promise;
        }
        // no need to transition when the active view isn't being removed
        // there's still an active view after _remove() figured out states
        // so this means views that were only removed before the active
        // view, so auto-resolve since no transition needs to happen
        return Promise.resolve(false);
    };
    /**
     * @private
     */
    NavController.prototype._remove = function (startIndex, removeCount) {
        var _this = this;
        // when this is done, there should only be at most
        // 1 STATE_INIT_ENTER and 1 STATE_INIT_LEAVE
        // there should not be any that are STATE_ACTIVE after this is done
        var view = null;
        // loop through each view that is set to be removed
        for (var i = startIndex, ii = removeCount + startIndex; i < ii; i++) {
            view = this.getByIndex(i);
            if (!view)
                break;
            if (view.state === STATE_TRANS_ENTER || view.state === STATE_TRANS_LEAVE) {
                // oh no!!! this view should be removed, but it's
                // actively transitioning in at the moment!!
                // since it's viewable right now, let's just set that
                // it should be removed after the transition
                view.state = STATE_REMOVE_AFTER_TRANS;
            }
            else {
                // if this view is already leaving then no need to immediately
                // remove it, otherwise set the remove state
                // this is useful if the view being removed isn't going to
                // animate out, but just removed from the stack, no transition
                view.state = STATE_REMOVE;
            }
        }
        if (view = this.getByState(STATE_INIT_LEAVE)) {
            // looks like there's already an active leaving view
            // reassign previous entering view to just be inactive
            var enteringView = this.getByState(STATE_INIT_ENTER);
            if (enteringView) {
                enteringView.state = STATE_INACTIVE;
            }
            // from the index of the leaving view, go backwards and
            // find the first view that is inactive
            for (var i = this.indexOf(view) - 1; i >= 0; i--) {
                if (this._views[i].state === STATE_INACTIVE) {
                    this._views[i].state = STATE_INIT_ENTER;
                    break;
                }
            }
        }
        else if (view = this.getByState(STATE_TRANS_LEAVE)) {
            // an active transition is happening, but a new transition
            // still needs to happen force this view to be the active one
            view.state = STATE_FORCE_ACTIVE;
        }
        else if (view = this.getByState(STATE_REMOVE)) {
            // there is no active transition about to happen
            // find the first view that is supposed to be removed and
            // set that it is the init leaving view
            // the first view to be removed, it should init leave
            view.state = STATE_INIT_LEAVE;
            view.willUnload();
            // from the index of the leaving view, go backwards and
            // find the first view that is inactive so it can be the entering
            for (var i = this.indexOf(view) - 1; i >= 0; i--) {
                if (this._views[i].state === STATE_INACTIVE) {
                    this._views[i].state = STATE_INIT_ENTER;
                    break;
                }
            }
        }
        // if there is still an active view, then it wasn't one that was
        // set to be removed, so there actually won't be a transition at all
        view = this.getActive();
        if (view) {
            // the active view remains untouched, so all the removes
            // must have happened before it, so really no need for transition
            view = this.getByState(STATE_INIT_ENTER);
            if (view) {
                // if it was going to enter, then just make inactive
                view.state = STATE_INACTIVE;
            }
            view = this.getByState(STATE_INIT_LEAVE);
            if (view) {
                // this was going to leave, so just remove it completely
                view.state = STATE_REMOVE;
            }
        }
        // remove views that have been set to be removed, but not
        // apart of any transitions that will eventually happen
        this._views.filter(function (v) { return v.state === STATE_REMOVE; }).forEach(function (view) {
            view.willLeave();
            view.didLeave();
            _this._views.splice(_this.indexOf(view), 1);
            view.destroy();
        });
        return this.getByState(STATE_INIT_LEAVE);
    };
    /**
     * @private
     */
    NavController.prototype._transition = function (enteringView, leavingView, opts, done) {
        var _this = this;
        var transId = ++this._transIds;
        if (enteringView === leavingView) {
            // if the entering view and leaving view are the same thing don't continue
            this._transFinish(transId, enteringView, leavingView, null, false);
            return done(false);
        }
        // lets time this sucker, ready go
        var wtfScope = instrumentation_1.wtfStartTimeRange('NavController#_transition', (enteringView && enteringView.name));
        if (this.config.get('animate') === false ||
            (this._views.length === 1 && !this._init)) {
            opts.animate = false;
        }
        if (!leavingView) {
            // if no leaving view then create a bogus one
            leavingView = new view_controller_1.ViewController();
        }
        if (!enteringView) {
            // if no entering view then create a bogus one
            enteringView = new view_controller_1.ViewController();
            enteringView.loaded();
        }
        /* Async steps to complete a transition
          1. _render: compile the view and render it in the DOM. Load page if it hasn't loaded already. When done call postRender
          2. _postRender: Run willEnter/willLeave, then wait a frame (change detection happens), then call beginTransition
          3. _beforeTrans: Create the transition's animation, play the animation, wait for it to end
          4. _afterTrans: Run didEnter/didLeave, call _transComplete()
          5. _transComplete: Cleanup, remove cache views, then call the final callback
        */
        // begin the multiple async process of transitioning to the entering view
        this._render(transId, enteringView, leavingView, opts, function (hasCompleted) {
            _this._transFinish(transId, enteringView, leavingView, opts.direction, hasCompleted);
            instrumentation_1.wtfEndTimeRange(wtfScope);
            done(hasCompleted);
        });
    };
    /**
     * @private
     */
    NavController.prototype._render = function (transId, enteringView, leavingView, opts, done) {
        // compile/load the view into the DOM
        var _this = this;
        if (enteringView.state === STATE_INACTIVE) {
            // this entering view is already set to inactive, so this
            // transition must be canceled, so don't continue
            return done();
        }
        enteringView.state = STATE_INIT_ENTER;
        leavingView.state = STATE_INIT_LEAVE;
        // remember if this nav is already transitioning or not
        var isAlreadyTransitioning = this.isTransitioning();
        if (enteringView.isLoaded()) {
            // already compiled this view, do not load again and continue
            this._postRender(transId, enteringView, leavingView, isAlreadyTransitioning, opts, done);
        }
        else {
            // view has not been compiled/loaded yet
            // continue once the view has finished compiling
            // DOM WRITE
            this.setTransitioning(true, 500);
            this.loadPage(enteringView, null, opts, function () {
                if (enteringView.onReady) {
                    // this entering view needs to wait for it to be ready
                    // this is used by Tabs to wait for the first page of
                    // the first selected tab to be loaded
                    enteringView.onReady(function () {
                        enteringView.loaded();
                        _this._postRender(transId, enteringView, leavingView, isAlreadyTransitioning, opts, done);
                    });
                }
                else {
                    enteringView.loaded();
                    _this._postRender(transId, enteringView, leavingView, isAlreadyTransitioning, opts, done);
                }
            });
        }
    };
    /**
     * @private
     */
    NavController.prototype._postRender = function (transId, enteringView, leavingView, isAlreadyTransitioning, opts, done) {
        // called after _render has completed and the view is compiled/loaded
        var _this = this;
        if (enteringView.state === STATE_INACTIVE) {
            // this entering view is already set to inactive, so this
            // transition must be canceled, so don't continue
            return done();
        }
        if (!opts.preload) {
            // the enteringView will become the active view, and is not being preloaded
            // set the correct zIndex for the entering and leaving views
            // if there's already another trans_enter happening then
            // the zIndex for the entering view should go off of that one
            // DOM WRITE
            var lastestLeavingView = this.getByState(STATE_TRANS_ENTER) || leavingView;
            this._setZIndex(enteringView, lastestLeavingView, opts.direction);
            // make sure the entering and leaving views are showing
            // DOM WRITE
            if (isAlreadyTransitioning) {
                // the previous transition was still going when this one started
                // so to be safe, only update showing the entering/leaving
                // don't hide the others when they could still be transitioning
                enteringView.domCache(true, this._renderer);
                leavingView.domCache(true, this._renderer);
            }
            else {
                // there are no other transitions happening but this one
                // only entering/leaving should show, all others hidden
                this._views.forEach(function (view) {
                    var shouldShow = (view === enteringView) || (view === leavingView);
                    view.domCache(shouldShow, _this._renderer);
                });
            }
            // call each view's lifecycle events
            enteringView.willEnter();
            leavingView.willLeave();
        }
        else {
            // this view is being preloaded, don't call lifecycle events
            // transition does not need to animate
            opts.animate = false;
        }
        this._beforeTrans(enteringView, leavingView, opts, done);
    };
    /**
     * @private
     */
    NavController.prototype._beforeTrans = function (enteringView, leavingView, opts, done) {
        // called after one raf from postRender()
        // create the transitions animation, play the animation
        // when the transition ends call wait for it to end
        var _this = this;
        if (enteringView.state === STATE_INACTIVE) {
            // this entering view is already set to inactive, so this
            // transition must be canceled, so don't continue
            return done();
        }
        enteringView.state = STATE_TRANS_ENTER;
        leavingView.state = STATE_TRANS_LEAVE;
        // everything during the transition should runOutsideAngular
        this._zone.runOutsideAngular(function () {
            // init the transition animation
            var transitionOpts = {
                animation: opts.animation,
                direction: opts.direction,
                duration: opts.duration,
                easing: opts.easing,
                renderDelay: opts.transitionDelay || _this._trnsDelay,
                isRTL: _this.config.platform.isRTL()
            };
            var transAnimation = transition_1.Transition.createTransition(enteringView, leavingView, transitionOpts);
            _this._trans && _this._trans.destroy();
            _this._trans = transAnimation;
            if (opts.animate === false) {
                // force it to not animate the elements, just apply the "to" styles
                transAnimation.duration(0);
            }
            var duration = transAnimation.getDuration();
            var enableApp = (duration < 64);
            // block any clicks during the transition and provide a
            // fallback to remove the clickblock if something goes wrong
            _this._app.setEnabled(enableApp, duration);
            _this.setTransitioning(!enableApp, duration);
            if (enteringView.viewType) {
                transAnimation.before.addClass(enteringView.viewType);
            }
            // create a callback for when the animation is done
            transAnimation.onFinish(function (hasCompleted) {
                // transition animation has ended
                // destroy the animation and it's element references
                transAnimation.destroy();
                _this._afterTrans(enteringView, leavingView, opts, hasCompleted, done);
            });
            // cool, let's do this, start the transition
            if (opts.progressAnimation) {
                // this is a swipe to go back, just get the transition progress ready
                // kick off the swipe animation start
                transAnimation.progressStart();
            }
            else {
                // this is a normal animation
                // kick it off and let it play through
                transAnimation.play();
            }
        });
    };
    /**
     * @private
     */
    NavController.prototype._afterTrans = function (enteringView, leavingView, opts, hasCompleted, done) {
        // transition has completed, update each view's state
        // place back into the zone, run didEnter/didLeave
        // call the final callback when done
        var _this = this;
        // run inside of the zone again
        this._zone.run(function () {
            if (!opts.preload && hasCompleted) {
                enteringView.didEnter();
                leavingView.didLeave();
            }
            if (enteringView.state === STATE_INACTIVE) {
                // this entering view is already set to inactive, so this
                // transition must be canceled, so don't continue
                return done(hasCompleted);
            }
            if (opts.keyboardClose !== false && _this._keyboard.isOpen()) {
                // the keyboard is still open!
                // no problem, let's just close for them
                _this._keyboard.close();
                _this._keyboard.onClose(function () {
                    // keyboard has finished closing, transition complete
                    done(hasCompleted);
                }, 32);
            }
            else {
                // all good, transition complete
                done(hasCompleted);
            }
        });
    };
    /**
     * @private
     */
    NavController.prototype._transFinish = function (transId, enteringView, leavingView, direction, hasCompleted) {
        // a transition has completed, but not sure if it's the last one or not
        // check if this transition is the most recent one or not
        var _this = this;
        if (transId === this._transIds) {
            // ok, good news, there were no other transitions that kicked
            // off during the time this transition started and ended
            if (hasCompleted) {
                // this transition has completed as normal
                // so the entering one is now the active view
                // and the leaving view is now just inactive
                if (enteringView.state !== STATE_REMOVE_AFTER_TRANS) {
                    enteringView.state = STATE_ACTIVE;
                }
                if (leavingView.state !== STATE_REMOVE_AFTER_TRANS) {
                    leavingView.state = STATE_INACTIVE;
                }
                // only need to do all this clean up if the transition
                // completed, otherwise nothing actually changed
                // destroy all of the views that come after the active view
                this._cleanup();
                // make sure only this entering view and PREVIOUS view are the
                // only two views that are not display:none
                leavingView = this.getPrevious(enteringView);
                this._views.forEach(function (view) {
                    var shouldShow = (view === enteringView) || (view === leavingView);
                    view.domCache(shouldShow, _this._renderer);
                });
                // this check only needs to happen once, which will add the css
                // class to the nav when it's finished its first transition
                if (!this._init) {
                    this._init = true;
                    this._renderer.setElementClass(this.elementRef.nativeElement, 'has-views', true);
                }
            }
            else {
                // this transition has not completed, meaning the
                // entering view did not end up as the active view
                // this would happen when swipe to go back started
                // but the user did not complete the swipe and the
                // what was the active view stayed as the active view
                leavingView.state = STATE_ACTIVE;
                enteringView.state = STATE_INACTIVE;
            }
            // allow clicks and enable the app again
            this._app && this._app.setEnabled(true);
            this.setTransitioning(false);
            if (this.router && direction !== null && hasCompleted) {
                // notify router of the state change if a direction was provided
                this.router.stateChange(direction, enteringView);
            }
            // see if we should add the swipe back gesture listeners or not
            this._sbCheck();
        }
        else {
            // darn, so this wasn't the most recent transition
            // so while this one did end, there's another more recent one
            // still going on. Because a new transition is happening,
            // then this entering view isn't actually going to be the active
            // one, so only update the state to active/inactive if the state
            // wasn't already updated somewhere else during its transition
            if (enteringView.state === STATE_TRANS_ENTER) {
                enteringView.state = STATE_INACTIVE;
            }
            if (leavingView.state === STATE_TRANS_LEAVE) {
                leavingView.state = STATE_INACTIVE;
            }
        }
    };
    NavController.prototype._cleanup = function () {
        var _this = this;
        // ok, cleanup time!! Destroy all of the views that are
        // INACTIVE and come after the active view
        var activeViewIndex = this.indexOf(this.getActive());
        var destroys = this._views.filter(function (v) { return v.state === STATE_REMOVE_AFTER_TRANS; });
        for (var i = activeViewIndex + 1; i < this._views.length; i++) {
            if (this._views[i].state === STATE_INACTIVE) {
                destroys.push(this._views[i]);
            }
        }
        // all pages being destroyed should be removed from the list of
        // pages and completely removed from the dom
        destroys.forEach(function (view) {
            _this._views.splice(_this.indexOf(view), 1);
            view.destroy();
        });
    };
    /**
     * @private
     */
    NavController.prototype.loadPage = function (view, navbarContainerRef, opts, done) {
        var _this = this;
        var wtfTimeRangeScope = instrumentation_1.wtfStartTimeRange('NavController#loadPage', view.name);
        // guts of DynamicComponentLoader#loadIntoLocation
        this._compiler && this._compiler.compileInHost(view.componentType).then(function (hostProtoViewRef) {
            var wtfScope = instrumentation_1.wtfCreateScope('NavController#loadPage_After_Compile')();
            var providers = _this.providers.concat(core_1.Injector.resolve([
                core_1.provide(view_controller_1.ViewController, { useValue: view }),
                core_1.provide(nav_params_1.NavParams, { useValue: view.getNavParams() })
            ]));
            var location = _this.elementRef;
            if (_this._anchorName) {
                location = _this._viewManager.getNamedElementInComponentView(location, _this._anchorName);
            }
            var viewContainer = _this._viewManager.getViewContainer(location);
            var hostViewRef = viewContainer.createHostView(hostProtoViewRef, viewContainer.length, providers);
            var pageElementRef = _this._viewManager.getHostElement(hostViewRef);
            var component = _this._viewManager.getComponent(pageElementRef);
            // auto-add page css className created from component JS class name
            var cssClassName = util_1.pascalCaseToDashCase(view.componentType['name']);
            _this._renderer.setElementClass(pageElementRef.nativeElement, cssClassName, true);
            view.addDestroy(function () {
                // ensure the element is cleaned up for when the view pool reuses this element
                _this._renderer.setElementAttribute(pageElementRef.nativeElement, 'class', null);
                _this._renderer.setElementAttribute(pageElementRef.nativeElement, 'style', null);
                // remove the page from its container
                var index = viewContainer.indexOf(hostViewRef);
                if (!hostViewRef.destroyed && index !== -1) {
                    viewContainer.remove(index);
                }
            });
            // a new ComponentRef has been created
            // set the ComponentRef's instance to this ViewController
            view.setInstance(component);
            // remember the ElementRef to the ion-page elementRef that was just created
            view.setPageRef(pageElementRef);
            if (!navbarContainerRef) {
                navbarContainerRef = view.getNavbarViewRef();
            }
            var navbarTemplateRef = view.getNavbarTemplateRef();
            if (navbarContainerRef && navbarTemplateRef) {
                var navbarViewRef = navbarContainerRef.createEmbeddedView(navbarTemplateRef);
                view.addDestroy(function () {
                    var index = navbarContainerRef.indexOf(navbarViewRef);
                    if (!navbarViewRef.destroyed && index > -1) {
                        navbarContainerRef.remove(index);
                    }
                });
            }
            opts.postLoad && opts.postLoad(view);
            instrumentation_1.wtfEndTimeRange(wtfTimeRangeScope);
            instrumentation_1.wtfLeave(wtfScope);
            done(view);
        });
    };
    /**
     * @private
     */
    NavController.prototype.swipeBackStart = function () {
        // default the direction to "back"
        var opts = {
            direction: 'back',
            progressAnimation: true
        };
        // figure out the states of each view in the stack
        var leavingView = this._remove(this._views.length - 1, 1);
        if (leavingView) {
            opts.animation = leavingView.getTransitionName(opts.direction);
            // get the view thats ready to enter
            var enteringView = this.getByState(STATE_INIT_ENTER);
            // start the transition, fire callback when done...
            this._transition(enteringView, leavingView, opts, function (hasCompleted) {
                // swipe back has finished!!
                void 0;
            });
        }
    };
    /**
     * @private
     */
    NavController.prototype.swipeBackProgress = function (stepValue) {
        if (this._trans && this._sbGesture) {
            // continue to disable the app while actively dragging
            this._app.setEnabled(false, 4000);
            this.setTransitioning(true, 4000);
            // set the transition animation's progress
            this._trans.progressStep(stepValue);
        }
    };
    /**
     * @private
     */
    NavController.prototype.swipeBackEnd = function (shouldComplete, currentStepValue) {
        if (this._trans && this._sbGesture) {
            // the swipe back gesture has ended
            this._trans.progressEnd(shouldComplete, currentStepValue);
        }
    };
    /**
     * @private
     */
    NavController.prototype._sbCheck = function () {
        var _this = this;
        if (this._sbEnabled) {
            // this nav controller can have swipe to go back
            if (!this._sbGesture) {
                // create the swipe back gesture if we haven't already
                var opts = {
                    edge: 'left',
                    threshold: this._sbThreshold
                };
                this._sbGesture = new swipe_back_1.SwipeBackGesture(this.getNativeElement(), opts, this);
            }
            if (this.canSwipeBack()) {
                // it is be possible to swipe back
                if (!this._sbGesture.isListening) {
                    this._zone.runOutsideAngular(function () {
                        // start listening if it's not already
                        void 0;
                        _this._sbGesture.listen();
                    });
                }
            }
            else if (this._sbGesture.isListening) {
                // it should not be possible to swipe back
                // but the gesture is still listening
                void 0;
                this._sbGesture.unlisten();
            }
        }
    };
    Object.defineProperty(NavController.prototype, "swipeBackEnabled", {
        /**
         * @input {boolean} Whether it's possible to swipe-to-go-back on this nav controller or not.
         */
        get: function () {
            return this._sbEnabled;
        },
        set: function (val) {
            this._sbEnabled = util_1.isTrueProperty(val);
        },
        enumerable: true,
        configurable: true
    });
    /**
     * If it's possible to use swipe back or not. If it's not possible
     * to go back, or swipe back is not enable then this will return false.
     * If it is possible to go back, and swipe back is enabled, then this
     * will return true.
     * @returns {boolean} Whether you can swipe to go back
     */
    NavController.prototype.canSwipeBack = function () {
        return (this._sbEnabled && !this.isTransitioning() && this._app.isEnabled() && this.canGoBack());
    };
    /**
     * Returns `true` if there's a valid previous page that we can pop back to.
     * Otherwise returns false.
     * @returns {boolean} Whether there is a page to go back to
     */
    NavController.prototype.canGoBack = function () {
        var activeView = this.getActive();
        if (activeView) {
            return activeView.enableBack();
        }
        return false;
    };
    /**
     * Boolean if the nav controller is actively transitioning or not.
     * @private
     * @return {boolean}
     */
    NavController.prototype.isTransitioning = function () {
        return (this._trnsTime > Date.now());
    };
    /**
     * @private
     * @return {boolean}
     */
    NavController.prototype.setTransitioning = function (isTransitioning, fallback) {
        if (fallback === void 0) { fallback = 700; }
        this._trnsTime = (isTransitioning ? Date.now() + fallback : 0);
    };
    /**
     * @private
     * @returns {ViewController}
     */
    NavController.prototype.getByState = function (state) {
        for (var i = this._views.length - 1; i >= 0; i--) {
            if (this._views[i].state === state) {
                return this._views[i];
            }
        }
        return null;
    };
    /**
     * @param {number} index  The index of the page you want to get
     * @returns {ViewController} Returns the component that matches the index given
     */
    NavController.prototype.getByIndex = function (index) {
        return (index < this._views.length && index > -1 ? this._views[index] : null);
    };
    /**
     * @returns {ViewController} Returns the active page's view controller.
     */
    NavController.prototype.getActive = function () {
        return this.getByState(STATE_ACTIVE);
    };
    /**
     * @param {ViewController} view
     * @returns {boolean}
     */
    NavController.prototype.isActive = function (view) {
        return !!(view && view.state === STATE_ACTIVE);
    };
    /**
     * @param {ViewController} view  The ViewController to get the previous view to
     * @returns {viewController}
     */
    NavController.prototype.getPrevious = function (view) {
        return this.getByIndex(this.indexOf(view) - 1);
    };
    /**
     * First page in this nav controller's stack.
     * @returns {ViewController} Returns the first component page in the current stack
     */
    NavController.prototype.first = function () {
        return (this._views.length ? this._views[0] : null);
    };
    /**
     * Last page in this nav controller's stack. This would not return a page which is about to be destroyed.
     * @returns {ViewController} Returns the last component page in the current stack
     */
    NavController.prototype.last = function () {
        return (this._views.length ? this._views[this._views.length - 1] : null);
    };
    /**
     * @param {ViewController} view
     * @returns {number} Returns the index number of the view
     */
    NavController.prototype.indexOf = function (view) {
        return this._views.indexOf(view);
    };
    /**
     * Number of sibling views in the nav controller.
     * @returns {number} The number of views in stack, including the current view
     */
    NavController.prototype.length = function () {
        return this._views.length;
    };
    Object.defineProperty(NavController.prototype, "rootNav", {
        /**
         * Returns the root NavController.
         * @returns {NavController}
         */
        get: function () {
            var nav = this;
            while (nav.parent) {
                nav = nav.parent;
            }
            return nav;
        },
        enumerable: true,
        configurable: true
    });
    /**
     * @private
     * @param {TODO} router  TODO
     */
    NavController.prototype.registerRouter = function (router) {
        this.router = router;
    };
    /**
     * @private
     */
    NavController.prototype._incId = function (view) {
        view.id = this.id + '-' + (++this._ids);
    };
    /**
     * @private
     */
    NavController.prototype._setZIndex = function (enteringView, leavingView, direction) {
        if (enteringView) {
            // get the leaving view, which could be in various states
            if (!leavingView || !leavingView.isLoaded()) {
                enteringView.setZIndex(INIT_ZINDEX, this._renderer);
            }
            else if (direction === 'back') {
                // moving back
                enteringView.setZIndex(leavingView.zIndex - 1, this._renderer);
            }
            else {
                // moving forward
                enteringView.setZIndex(leavingView.zIndex + 1, this._renderer);
            }
        }
    };
    __decorate([
        core_1.Input(),
        __metadata('design:type', Boolean)
    ], NavController.prototype, "swipeBackEnabled", null);
    return NavController;
})(ion_1.Ion);
exports.NavController = NavController;
var STATE_ACTIVE = 'active';
var STATE_INACTIVE = 'inactive';
var STATE_INIT_ENTER = 'init_enter';
var STATE_INIT_LEAVE = 'init_leave';
var STATE_TRANS_ENTER = 'trans_enter';
var STATE_TRANS_LEAVE = 'trans_leave';
var STATE_REMOVE = 'remove';
var STATE_REMOVE_AFTER_TRANS = 'remove_after_trans';
var STATE_FORCE_ACTIVE = 'force_active';
var INIT_ZINDEX = 10;
var ctrlIds = -1;


text:
What all the losing is doing to Giants' best rookies
By Paul Schwartz
October 26, 2017 | 6:46pm
Eli Manning's quiet new suburban life hints at Giants closure
Daniel Jones' new Giants mentor even left Dan Marino impressed
Giants hire Jason Garrett as offensive coordinator
Ben McAdoo's NFL exile may be over
The question would have stumped most players inside the Giants locker room, but not Dalvin Tomlinson.
Quick quiz: How many games did you lose in your entire college career?
Tomlinson, the rookie defensive tackle from Alabama, paused but for only a few seconds as he started up a mental accounting process. You could see him silently nod for each loss as he counted them up in his head.
This was not advanced mathematics.
"Um, around six, total, I want to say," Tomlinson said.
Ding. We have a winner.
In less than two months, Tomlinson has lost as many games in his NFL life with the Giants as he did in four years playing for the Crimson Tide. He is 1-6 with the Giants after going 51-6 in his college career. If you want to count his 2012 redshirt year, when he did not play, Tomlinson was 64-7 during his time on the Tuscaloosa campus.
There are all sorts of adjustments rookies must make in their first year in the NFL. For Tomlinson, learning the ins and outs of defeating blocks on the next level is moving along according to plan, and the second-round pick looks as if he will be a fixture on the defensive line for years to come. Evan Engram, the first-round pick from Ole Miss, leads all rookie tight ends with 30 receptions for 342 yards and three touchdowns. The 342 receiving yards tops all rookies, period. The top two Giants picks in the 2017 NFL Draft have the look of keepers, 23-year-olds who have fit in easily, on the field and off it. As they take a break for their first professional bye week, both feel the strain of so much losing.
Tomlinson tackles LeGarrette Blount during a loss to the Eagles in September.AP
"It's been a mental adjustment, but being a football athlete, you have to be mentally tough and you got to face adversity," Tomlinson said.
"I mean, it's tough to be pleased when we're losing as a team," Engram said. "With a loss, it's kind of hard to feel good about it. There's always things that you can look back on — maybe if I did this better, we score here or if I did this better, we get this first down — so it's definitely tough to kind of enjoy playing well but not getting the results we want as a team."
In this dreary Giants season, there is hope for the future in that it looks as if general manager Jerry Reese got it right with the marquee players in his draft class, although an argument certainly can be made at least one offensive lineman was the more prudent way to go. Jay Bromley hurt his knee in the preseason against the Jets, opening the door for Tomlinson, who has started every game, working in a rotation with Bromley on the interior of the defensive line alongside Damon Harrison. The 6-foot-3, 317-pound Tomlinson is Pro Football Focus' No. 1-graded rookie interior defensive linemen and ranks 23rd out of 121 among all defensive tackles. Tomlinson has not shown much as a pass-rusher, but his grade against the run puts him 10th in the NFL.
Tomlinson said his "I'm in the NFL now" moment came early in the season.
Rookie Evan Engram grows into role as Giants' only playmaker
In losing all of their starting wide receivers, the Giants...
"Pretty much breaking down film of all the quarterbacks I'm playing against and I'm like, 'I used to play with this guy in Madden,'" he said. "I used to watch these guys. Now I'm playing against them. It's crazy."
Engram was supposed to have so much offensive talent around him that he could create matchup advantages without being the center of attention. Season-ending injuries to Odell Beckham Jr. and Brandon Marshall and Sterling Shepard missing the past two games with a sprained ankle made Engram a force-fed-by-default target for Eli Manning.
Engram has embraced the increased responsibility, trying to pick up the slack for his injured teammates, but he grew wide-eyed when reminded he has more games yet to play (nine) than he already has played (seven).
"Yeah, that's the craziest thing," Engram said. "I mean, coming into it, people kind of tried to warn me about the length of the season and the rookie wall, but it's really not that bad. I think it's kind of a mentality. It's tough right now for us, but I'm enjoying each and every day coming up here and putting the work in."
Filed under dalvin tomlinson , evan engram , new york giants
Odell Beckham's dad arrested on gun, weed charges
Mike Vaccaro
Why your Astros cheating anger likely won't last long
THE BEST INSIGHTS FROM THE ULTIMATE INSIDERS
Big Apple Buckets: A NY Knicks Podcast
Listen on Apple Podcasts | Spotify
Blue Rush: A NY Giants Podcast
Gang's All Here: A NY Jets Podcast
Up In The Blue Seats: A NY Rangers Podcast
Get the latest odds on all the top sports.
See Odds

redpajama_set_name: RedPajamaCommonCrawl


text:
Chosuke Sato (佐藤長助, Sato Chosuke ; né le  à Sendai – décédé le , est un compositeur et chef d'orchestre japonais.

Biographie
Sato étudie à l'académie militaire de la musique dont il est diplômé en 1926. Par la suite, il est maître de chapelle militaire avec plusieurs formations. Il occupe cette position jusqu'à la Seconde Guerre mondiale. Après la guerre, il est chef arrangeur et compositeur auprès de la société King Records à Tokyo. Il travaille ensuite pour la radiodiffusion et la télévision japonaises.

Compositions

Orchestre d'harmonie
 1964 Dances on Folk Song à partir de chants populaires de Sendai
 1966 Ouverture Gakuen
 1967 Fantasies
 1973 Hotaka Renpo, suite
 1973 Opening Ceremony
 Army March - texte Sazanami Iwaya
 In the Morning Sun - texte Masaharu Honma
 My Horse "Line" - texte Shizuka Nakagawa
 Obone-Bushi

Musique vocale
 Song miyagino Basin
 Whole Man, lied - texte Koji Yume

Musique de film
 1941 Kimi to boku

Bibliographie
 Wolfgang Suppan et  : Das Neue Lexikon des Blasmusikwesens, 4. Auflage, Blasmusikverlag Schulz GmbH, 1994, 690 p.,
 Paul E. Bierley, William H. Rehrig : The heritage encyclopedia of band music : composers and their music, Westerville, Ohio: Integrity Press, 1991,
 Hitoshi Matsushita : A checklist of published instrumental music by Japanese composers, Tokyo: Academia Music Ltd., 1989,

Liens externes

Source de la traduction

Compositeur japonais de musique classique de la période moderne
Chef d'orchestre japonais
Naissance à Sendai
Naissance en avril 1906
Décès en septembre 1983
Décès à 77 ans
Compositeur de musique pour orchestre d'harmonie

redpajama_set_name: RedPajamaWikipedia


text:
YouTube ranter wins battle over interest rates
Mitch Lipka
A California woman who made a widely publicized YouTube video calling for a "Debtors Revolt" -- announcing she wouldn't be paying her credit card bills because her interest rates skyrocketed -- has a new video proclaiming a personal victory.
Ann Minch, whose first video posted two weeks ago was seen by about a quarter million people, said in her follow-up installment that she received a call from an executive at Bank of America who agreed, after a little negotiation, to restore her interest rate to its previous level of 12.99%.
She said in the video that she told the executive that banks are borrowing money from the federal government essentially for free so getting nearly 13% interest was adequate profit. Minch said he relented, never asked her to alter or remove her fiery video and then accepted the victory as a personal win.
A Bank of America spokeswoman told WalletPop that the bank did work out a deal with Minch, but said she couldn't be more specific.
"We did reach out to the customer and, based on additional information we received from her about her situation, we reached a mutually agreeable resolution," spokeswoman Betty Riiess said. "Because of customer privacy, I can't discuss the specific terms of the customer's account."
While Minch's 10 minutes in the spotlight might be nearing an end, she said much is left to be done to try to get banks to treat their customers more fairly and urged a continuation of the fight.
Minch said her interest rate was raised to 30% even though she was a longstanding customer and always made her payments on time.
"I could get a better rate from a loan shark," Minch said in the video. "There comes a time when we must make a stand and my time is now."
A number of credit card issuers boosted rates and changed terms on their cardholders ahead of a federal law that reins in such acts.
Minch made mention of the advice many have offered to try to negotiate a lower rate with your bank -- a tactic that has worked for some. But she said her attempts had failed until her video went viral thanks, in large part, to a story on the Huffington Post site.
BankOfAmerica
consumer ally
ConsumerAlly
InterestRate


I honestly can not say when I will have time to blog again between today and the start of 2016, so I would like to take this opportunity to wish all my followers, readers, friends and anyone else who happens to see this a very happy festive season.
I hope that you will all be safe and have a relaxing and fun filled time with whoever you choose to spend this time with. Regardless of faith, belief, spirituality, ethnicity, culture or anything else that serves to divide us I send my sincere wishes for a safe and peaceful period for you and those you love.
Let's all spread a little love around. The world certainly needs it. If you can, please try and perform one random act of kindness in the next week. It will make you feel good and will have a multiplying effect on those around you.
Be safe and see you again in 2016 (if not sooner).
Have a AWESOME Christmas and a FABULOUS New Year! 🙂 Wishing you and your loved ones all the Blessings!


text:
SHAREHOLDER ALERT: Pomerantz Law Firm Investigates Claims On Behalf of Investors of Maxar Technologies Ltd. - MAXR
Pomerantz LLP
NEW YORK, Aug. 13, 2018 /PRNewswire/ -- Pomerantz LLP is investigating claims on behalf of investors of Maxar Technologies Ltd. ("Maxar" or the "Company") (NYSE: MAXR). Such investors are advised to contact Robert S. Willoughby at [email protected] or 888-476-6529, ext. 9980.
The investigation concerns whether Maxar and certain of its officers and/or directors have engaged in securities fraud or other unlawful business practices.
[Click here to join a class action]
On August 7, 2018, Spruce Point Capital Management ("Spruce Point") published a research report on Maxar. The Spruce Point report alleged, in part, that Maxar "has pulled one of the most aggressive accounting schemes Spruce Point has ever seen to inflate Non-IFRS earnings by 79%". Specifically, the report asserted that Maxar had used its acquisition of DigitalGlobe "to inflate [its] intangible assets" and had "amended its post-retirement benefit plan to book one-time gains" in a manner that "was not fully disclosed across its investor communications". Following publication of the Spruce Point report, Maxar's stock price fell sharply during intraday trading on August 7, 2018.
The Pomerantz Firm, with offices in New York, Chicago, Los Angeles, and Paris, is acknowledged as one of the premier firms in the areas of corporate, securities, and antitrust class litigation. Founded by the late Abraham L. Pomerantz, known as the dean of the class action bar, the Pomerantz Firm pioneered the field of securities class actions. Today, more than 80 years later, the Pomerantz Firm continues in the tradition he established, fighting for the rights of the victims of securities fraud, breaches of fiduciary duty, and corporate misconduct. The Firm has recovered numerous multimillion-dollar damages awards on behalf of class members. See www.pomerantzlaw.com.
Robert S. Willoughby
SOURCE Pomerantz LLP
http://www.pomerantzlaw.com
Pomerantz Law Firm Announces the Filing of a Class Action against ...


The Doctor(s) and staff at Acacia Animal Hospital believe in treating your pet as if he or she was a member of our family. We will recommend the same procedures and products we would want for our own pets and emphasize preventative care. Our Mission is to maximize the health of your pet.
Further the knowledge of our doctor and staff through seminars and continuing education courses.
Constantly apply the latest in veterinary medical advancements and technology to properly diagnose, treat, and care for our client's pets.
Our goal will be achieved when we have exceeded our client's expectations and they are comfortable in referring friends and family to Acacia Animal Hospital for the care of their pets.


text:
The United States Law Week
A mailbox is seen outside a United States Postal Service (USPS) post office location in Washington, DC, April 16, 2020.
Photographer: Saul Loeb/AFP via Getty Images
USPS Custom Postage Political Content Ban Unconstitutional
By Julie Steinberg
Rule too broad to provide objective, workable standards
Artist's claim not mooted by USPS actions in ending program
The U.S. Postal Service's 2018 rule disallowing political content on custom stamps is unconstitutional, the U.S. Court of Appeals for the District of Columbia Circuit said Tuesday, reversing dismissal of a challenge by an artist who designed stamps critical of a U.S. Supreme Court decision.
The rule's blanket ban on "political" content fails to provide "objective, workable standards" to guide the exercise of the government's discretion, as required by the Supreme Court in Minnesota Voters Alliance v. Mansky. There, the justices struck down Minnesota's ban on "political apparel" at polling places, the D.C. Circuit said.
Anatol Zukerman and Charles...
To read the full article log in. To learn more about a subscription click here.
Julie Steinberg
USPS Can Ban Politics From Novelty Custom Postage Stamps


We have drifting roads, closed schools and things piling up to do inside, but I worked a little on my Facebook page last night and this post comes from that. I still am learning about it. I also recently started Twitter (see to the right) and like everyone else, I'm learning, and wondering, is it worth my time? There is so much I want to do.
I have 5 books I'm reading for review for Church Libraries magazine, and I'm working on creating my own fiction--at last. It is a daunting proposition. Contemporary? Suspense? Comedy? Historical? Romance? Ok, now you know what I like to read. But I've helped several people go on to be published, so this is one of those lofty goals I dreamed about as a teen for myself. Time is a'tickin'. I actually wrote in the school newspaper that I wanted to write The Great American Novel. LOL. Now that is being idealistic and dreamy. But a gal's gotta try.
Once you've been tagged, you are supposed to write a note with 25 random things, facts, habits, or goals about you. At the end, choose 25 people to be tagged. You have to tag the person who tagged you. If I tagged you, it's because I want to know more about you, or you may have tagged me.
1. I am of Swedish, Norwegian, English, Irish, Scotch and Cherokee descent.I hope to use this in my own fiction, though I'm not sure I want to write my own historical fiction, but it's of my favorites to read.
2. I am a second generation American on my mother's side, who was Swedish and Norwegian and from Minnesota. My dad was from Tennessee and from a family who had lived in this country for generations, some on the same land that is still in our family with a graveyard of family dating back to the 1700s. They met in Indiana. I love stories of my family.
3. I won third place in an art contest in 6th grade where my teacher argued with his artist sister(the other judge) that my drawing was "too real" to be art. He didn't want to give me a prize at all; she wanted to give me first place. My prize was a compromise and he told me about it. It was a drawing of a man walking to his cabin with an ax over his shoulder, next to a lake with pine trees. I can still see it in my mind's eye. The picture is long gone. I still would like a cabin by a lake.
3. I competed in trapshooting tournaments around the country. I own my own Perazzi competition grade shotgun. It has a single barrel and double barrels that I can interchange to shoot either single clay targets or double clay targets thrown in the air from a traphouse.
4. I have owned 4 different competition grade shotguns: Ljutic, Kreighoff and 2 Perazzis.
5. I love the Italian Perazzi gunmakers who come to America every summer for the Grand American. I just look at them, look at their guns and smell the great food they are cooking in their building. I have talked to them a couple times about my gun that their family business made.
6. I once talked to a master German gunmaker on the phone about my shotgun, which was misfiring. He fixed it. He was very nice and actually listened to me.
7. I was trained by one of the top champions in trapshooting in the world, Kay Ohye. He believed in me as a shooter. Competition trapshooting takes a lot of time and money. I've competed in Arizona, Georgia, Michigan, Ohio, Tennessee and with the top competitors in the world, including my husband's family members. Two of my trapshooting buddies have died. One died this week. Ken is now "breaking 'em all!"
8. I learned to play the guitar when I was 12. My teacher, who later went to Nashville to try and be a songwriter, made me write my own songs and sing while playing my guitar.
9. I learned a lot of Neil Diamond songs because my guitar teacher loved Neil Diamond. His dog, a very large St. Bernard, loved ME and would slobber on my arm. My guitar teacher's wife would bring me a towel.
10. I took guitar back up when I was 45 but haven't played lately. I sometimes play bass in our band.
11. I've played and sang with a band. Our band has been paid money to play.
12. I'm not that good, but my family are all good at music and singing. My sons have their own bands, too.
13. My Tennessee family did not like my name Crystal and I really wasn't called Crystal until I married Chris over 25 years ago. They called me Crissy or Cris. I spelled my name "Chris" when I went to public school because I thought it was cool and my chance to be myself.
14. I love Southern food.
15. I also love Italian food.
16. I love to eat avocados,tomatoes, almonds, Herdez salsa, anything lime-flavored and Lay's Potato Chips. My favorite flavor is lime--anything with lime. I prefer salty and sour over sweet, but I love creme brulee dessert. I like coffee black, and did not drink it until I was 28 years old. I love Real Coca-Cola and will drink a Coke anytime! I might drink a diet Lime Coke, but hate Diet anything. I also love raspberry iced tea. Love to eat at all kinds of restaurants and talk to the chefs. My favorite thing to do is go out to eat with my husband, and our friends, Gary and Sue. I also love going with our boys, who make me laugh.
17. I once considered being a vegetarian like my mother's family, but I loved ham, bacon, sausage and hamburgers too much. But I sometimes will eat vegetarian for periods of time because it seems to make me lose weight!I think my body is suited for a vegetarian diet.
18. My favorite books as an elementary student were these childhood biographical historical fiction books and I have never seen them again as an adult. They were about historical people as children. My second favorite books were Little House on the Prairie books. However, my favorite stories, hands-down, were stories my mother told while I sat eating or drawing at the kitchen table. I've collected some of those stories from other family members, too, and found a whole line of our Irish family clear back to County Cavan in Ireland.
19. I sketched pictures all the time as a child. It was my favorite thing to do. I still sometimes sketch in my margins while taking notes. My HS art teacher wanted me to be an art major. I have a son who is now an art major in drawing. I have paintings from family who were artists, including my son and a former student named Erin.
20. My sixth grade teacher read to us Edgar Allan Poe stories and I was totally won over. I don't remember any other stories my teacher read, although he read to us every day after lunch recess.
21. The first book I bought through Scholastic Book Club in 6th grade (the year I went to public school, I was in a Christian school my first 5 years of school) was My Life and Hard Times by James Thurber. I still have that book. I thought he was hysterically funny. No one else got it--either the book or his humor.
22. I also loved anything written by Mark Twain. I did dozens of reports on him, including a paper in college. I still have a notebook I did on him.
23. I was in college when I first heard of C.S. Lewis. My cousin, Darrol, gave me a set of his outer space trilogy. I didn't know that I loved fantasy and science fiction until then. I have worked as a judge, book doctor and editor in the category of Christian speculative/ sci fi/ fantasy fiction.
24. I worked in the high school library for three years and read almost everything in there. I particularly remember East of Eden by John Steinbeck. James Dean, who was from our hometown, became famous in the movie based on that book. I read the book before I saw the movie.
25. I've published over 800 book reviews in magazines, wrote a book review column and parenting column, as well as many articles. I work as a freelance Christian fiction reader/editor/book doctor on assignment.
Here's a photo of me as a student teacher at Park Elementary. That was a lonnnnnnnnnnnnng time ago once upon a time. School pictures--gotta love 'em.
I'm supposed to tag people, but here's the deal--if you want to do this, go ahead and then mention where you got it. I'll come comment on yours!
Many people ask me how they can get published, and sometimes I even have worked with fiction authors in various capacities to progress to this goal. I also list books for them to read to move them along to that goal--to be published.
Now my friend, W. Terry Whalin, has a book out that will help you to reach your goal of being published. For many years he's given advice and tips on his blog The Writing Life. Check this video trailer out and get this book to Jumpstart Your Publishing Dreams!
My blog has been awarded the "Premio-Dardas" Award today by LeAnne of Beauty and the Beholder. If you have ever seen LeAnne's blogs, you've already seen what comprises very beautifully written and artistically-laid out blogs. I am so honored and not even in the same category.
Awards like this have been created with the intention of promoting community among Bloggers. It's a way to show appreciation and gratitude for work that adds value to the Web.
1. Accept the award, post it on your blog together with the name of the person who granted it to you, along with his/her blog link.
2. Pass the award to (15) other blogs that you feel are worthy of this recognition. Remember to contact each of them to let them know they have been chosen as recipients.
*Please note: when copying the award picture, please download it to your own computer first and upload from there to your own blog site.
10. Jude Urbanski at Hey, Jude!
Thanks, LeAnne, for passing the "Premio Dardas" to me. Now to go around to let these folks know!
For a chance to win an evaluation of your proposal by professional freelance reader,ME, visit Seekerville Monday, January 12.
The drawing will take place on Wednesday, January 14. Janet Dean will draw one winner for an evaluation of the first three chapters and synopsis of your manuscript. And if you don't need an evaluation of your fiction proposal, then just come by to say hi or add a comment.
Seekers always has some great advice and posts on writing (last week was fabulous!) so it's one of my favorites listed over at the right. I'm honored that they asked me to guest blog.
I swiped this meme off another blog, my good friend Nancy at Anchors, Signposts & Wanderings. You're supposed to post the 4th photo in your 4th file and then share the story about it.
This is my mother as a toddler. It's one of the very few photos my mother had of herself as a young person. She was the youngest daughter in a family of 10 kids. Her mother was the second wife of Aaron Pierson. His first wife died of TB and left 5 small children.
My great-grandparents (Ane and Bernt) and their daughter(my grandmother, Anna) went to Aaron's church and helped him out with his five young children after his wife's death, and so, Aaron married my grandmother. Then, they had five children, making 10 kids! My mother was the fourth child born to Anna and Aaron(they had one more, a son,) so Anna asked the older kids what they wanted to name my mother. They picked their sister's name--Lillian Arlene--a child who was the sixth child in the first family who died as an infant. My mother said it was strange to see her own name on a tombstone in the family plots!
My mother didn't have her mother very long. Her mom, not long after having another child (the son mentioned above) had TB and died when my mother was almost 6. Her older sisters, who had gone through this experience, too, you think would've been more compassionate to this small girl who was only 5 when losing her mother, but they often were cruel and harsh to her. On the morning of her 6th birthday she came down the stairs, sat at the table, expecting the same birthday delights that my grandmother always did for all the children--fixed them whatever they wanted for breakfast and making them Queen or King of the day. No. The older girls (teens and young 20s) snapped, "You're a big girl now. Get your own breakfast. You don't have your mother anymore." Harsh reality.
They continued their harsh treatment of my mother even after I came along--I got to witness it and feel the brunt of their disdain, as well. Certainly when my mother also got TB you would have thought they would take care of me--but no, and thank God that my dad's parents took me and loved me as their own child.
But this little girl was obviously happy, and her mother, though managing as a farm wife with nine-soon-to-be-ten children of various ages, delighted in birthdays and her carrier pigeons pets and a husband who was older but funny, despite having a hard life of his own. I think my mother looks happy and cared for, don't you? She has no idea of what is to come, but I do think she adopted her own mother's attitudes, despite being so young when she lost her.
So, do you want to play? If you have a blog, you might try this--find the fourth file and fourth picture and tell about it. Leave your link if you do.


" Featured Homes for Sale & Real Estate and Connect with Local Realtor "
Looking for Real Estate Services? VA Home Loan Advice? Selling or Buying Home? Move from Renter to Owner! Relocating?
Get a FREE Marketing Analysis of your home or simply request a Real Estate Consultation Now.
Veterans & Military Active Duty take advantage of VA Home Loan benefit afforded to you - you've certainly earned it. Check out this website for updated listings of homes for sale, local neighborhood and school details, mortgage information, interactive maps, plus many more features and useful real estate information about utilizing your VA benefits to secure a VA Home Loan, how to choose the "right" property, making an offer, negotiating, financing, mortgage rates, moving and everything involved in making an informed real estate decision in today's market.
FINDING the right Realtor for your home search is very important. An accomplished San Diego, California Realtor and Military Veteran will not only show you properties and sell real estate, but will also make the entire selling or buying process successful and smooth by assisting and becoming your personal Real Estate & Home Advisor.
Andre S. Hobbs of Coldwell Banker Real Estate Advisor is a "Locally Preferred Navy Veteran" that's been advising and supporting Military Active Duty & Veterans with Buying or Selling their new or next home for many years - certified Military Relocation Specialist, Top real estate agent and your Neighborhood Expert who can assist in your Chula Vista or San Diego Real Estate.
Currently SoCal State Director, Veterans Association of Real Estate Professionals (VAREP), San Diego Chapter - a non-profit 501(c)(3) organization for vets, by vets, dedicated to increasing sustainable home ownership, , financial-literacy education, VA loan awareness, and economic opportunity for the active-military and veteran communities.
Coldwell Banker "Presidential Circle" recipient (Top 10% Worldwide Selling Agents); Certified Coldwell Banker Global Luxury Markets / Designated Military Marketing & Relocation Specialist and conveniently located in Rancho del Rey (Chula Vista California) as your neighborhood expert throughout San Diego County. Member of California Association of Realtors, (CAR), National Association of Realtors (NAR), Pacific Southwest Association of Realtors (PSAR), Southwest Riverside Association of Realtors and many more.
SELLING A HOME in San Diego, CA or Chula Vista, CA area? Now that you are READY to list your home on the market - we can customize the selling program to meet your specific needs and timeline. No matter which market you're in, you can use marketing programs and experience of a qualified Chula Vista, CA real estate agent, like me, to help sell your home quickly and at the right price. Learn more about our service, see information about recent home sales in Chula Vista, CA, or contact us today!
FIND REAL ESTATE in San Diego, CA or Chula Vista, CA area? Finding the right home can be a difficult process but no matter what you are looking for - by using your VA Loan , you can get into a house with "NO Money Down" with credit scores as low as 580 depending on your entire loan profile - it is most common that a 620 (VA) or 640 (FHA/Conventional) FICO score required. As an experienced Chula Vista, CA real estate agent, I can provide you with the resources you need to make the home buying process simpler, from specific Chula Vista, CA neighborhood information, to tools to estimate your mortgage payments, and buyer resources and articles that will help you through the home buying process.
Coldwell Banker Chula Vista - Andre Hobbs Real Estate Advisors provides everything you would need to know about buying, selling, investing and financing, real estate or homes for sale. Call (619) 892-1008 TODAY if you have any questions about the San Diego or Chula Vista, CA real estate market, buying or selling a home throughout San Diego County or Chula Vista, CA - and I will be happy to assist you.
GET FREE Real Estate Advice - NOW!


AN EXCLUSIVE TAG HEUER PATENTED TECHNOLOGY: THE FIRST EVER MAGNETIC DOUBLE TOURBILLON The TAG Heuer Carrera MikroPendulumS is a TAG Heuer Carrera MikrotourbillonS with 2 magnetic Pendulums replacing the hairsprings, one for telling time and one for timekeeping. Composed of 454 working components and based on unique TAG Heuer-patented technology, its watch chain turns at 12Hz and its chronograph chain turns at 50Hz (60 minutes power reserve). The chronograph tourbillon, the world's fastest, controls the 1/100th of a second, beats 360,000 an hour and rotates 12 times a minute. The case is forged from a revolutionary material, a chrome and cobalt alloy used in aviation and surgery. It is fully biocompatible, harder than titanium, easier to shape and as luminous as white gold. The case design, with its stopwatch-like placement of the crown at 12 o'clock, is based on the 2012 Aiguille d'Or winner, the TAG Heuer Carrera Mikrogirder, and the Carrera 50 Year Anniversary Jack Heuer edition. The two tourbillon Pendulums and their solid rose gold bridges (18K 5N) are visible through the fine-brushed anthracite dial. The hand applied "100" at 12 o'clock is also in solid rose gold. The chronograph minutes counter is at 12 o'clock, chronograph seconds at 3, and the chronograph power reserve at 9. The 1/100th of a second scale appears on the silver flange. The strap is hand-sewn anthracite grey alligator, very high-tech in style and soft to the touch. This is a spectacular showcase of Swiss craft and TAG Heuer savoir-faire. The Baselworld unveiling of the brand's latest concept piece has become a "can't-miss" moment among watch lovers. The new TAG Heuer Carrera MikroPendulumS is sure to give them a lot to talk about.