mirror of https://github.com/jstrieb/urlpages.git
4 lines
267 KiB
HTML
4 lines
267 KiB
HTML
<script type="text/javascript">
|
|
window.location.replace("https://jstrieb.github.io/urlpages/#{"version":"0.2.0","compressed":false,"body":"<html class=\"flag-limitFabrikSave-on flag-facebookOauthButton-on flag-videoVHSCover-on flag-videoVHSShareTools-on flag-videoVHSEmbeddedOnly-on flag-removeInternationalEdition-on flag-piiBlockDFP-on flag-indexAsHeaderBidder-on flag-caslOpt-on moz desktop  has-comments blog-afterdeadline section-timestopics wf-active has-js has-flexbox has-flexboxlegacy has-canvas has-canvastext has-webgl has-no-touch has-geolocation has-postmessage has-no-websqldatabase has-indexeddb has-hashchange has-history has-draganddrop has-websockets has-rgba has-hsla has-multiplebgs has-backgroundsize has-borderimage has-borderradius has-boxshadow has-textshadow has-opacity has-cssanimations has-csscolumns has-cssgradients has-no-cssreflections has-csstransforms has-csstransforms3d has-csstransitions has-fontface has-generatedcontent has-video has-audio has-localstorage has-sessionstorage has-webworkers has-applicationcache has-svg has-inlinesvg has-smil has-svgclippaths has-cors tr-directwrite tr-aa-unknown-subpixel viewport-small viewport-small-10 viewport-small-20 viewport-medium viewport-medium-10 viewport-medium-20 viewport-medium-30 viewport-medium-31 viewport-medium-40 edition-domestic has-ribbon type-size-small\" itemscope=\"\" xmlns:og=\"//opengraphprotocol.org/schema/\" style=\"\" lang=\"en\"><!--<![endif]--><!--[if IE 9]> <html lang=\"en\" class=\"no-js ie9 lt-ie10 has-comments blog-afterdeadline section-timestopics\" xmlns:og=\"//opengraphprotocol.org/schema/\"> <![endif]--><!--[if IE 8]> <html lang=\"en\" class=\"no-js ie8 lt-ie10 lt-ie9 has-comments blog-afterdeadline section-timestopics\" xmlns:og=\"//opengraphprotocol.org/schema/\"> <![endif]--><!--[if (lt IE 8)]> <html lang=\"en\" class=\"no-js lt-ie10 lt-ie9 lt-ie8 has-comments blog-afterdeadline section-timestopics\" xmlns:og=\"//opengraphprotocol.org/schema/\"> <![endif]--><head>\n    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\n    <meta name=\"communityAssetLabels\" content=\"NYT_Blogs\">\n    <meta name=\"communityAssetTaxonomy\" content=\"blogs/afterdeadline/FAQs on Style\">\n    <meta name=\"communityAssetURL\" content=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/\">\n    <meta name=\"WT.z_gtn\" content=\"Blog\">\n    <meta name=\"PT\" content=\"Blogs\">\n    <meta name=\"PST\" content=\"Blog Post\">\n    <meta name=\"sourceApp\" content=\"blogs\">\n    <meta itemprop=\"identifier\" name=\"blogpostid\" content=\"100000005287458\">\n    <meta name=\"author\" content=\"Philip B. Corbett\">\n    <meta name=\"CLMST\" content=\"Philip B. Corbett\">\n    <meta name=\"byl\" content=\"Philip B. Corbett\">\n    <meta name=\"GBLC\" content=\"Times Topics\">\n    <meta name=\"PUV\" content=\"normal\">\n    <meta property=\"article:published_time\" itemprop=\"datePublished\" content=\"1271185698\">\n    <meta name=\"PUD\" content=\"20100413\">\n    <meta name=\"pdate\" content=\"20100413\">\n    <meta name=\"ptime\" content=\"20100413150818\">\n    <meta name=\"utime\" content=\"20170720160522\">\n    <meta property=\"article:modified_time\" itemprop=\"dateModified\" content=\"2017-07-20T16:05:22-04:00\">\n    <meta name=\"DISPLAYDATE\" content=\"April 13, 2010\">\n    <meta name=\"dat\" content=\"April 13, 2010\">\n    <meta itemprop=\"articleSection\" property=\"article:section\" content=\"After Deadline\">\n    <meta name=\"CG\" content=\"After Deadline\">\n    <meta name=\"SCG\" content=\"afterdeadline\">\n    <meta name=\"BN\" content=\"afterdeadline\">\n    <meta name=\"robots\" content=\"noodp\">\n    <meta property=\"article:tag\" content=\"Times Topics\">\n    <meta property=\"article:tag\" content=\"Uncategorized\">\n    <meta name=\"keywords\" content=\"Times Topics,Uncategorized\">\n    <link rel=\"alternate\" type=\"application/json+oembed\" href=\"https://www.nytimes.com/svc/oembed/json/?url=http%3A%2F%2Fafterdeadline.blogs.nytimes.com%2F2010%2F04%2F13%2Ffaqs-on-style%2F\" title=\"FAQs on Style\">\n    <meta name=\"description\" content=\"Many topics come up repeatedly in reader comments and e-mail messages to After Deadline. Unfortunately I’m not able to offer a direct response to each comment (truth be told, After Deadline is a sideline for me). But one thoughtful reader suggested that I compile answers for some of the most common questions. Here’s a start in that effort. I’ll add other topics as they come up, and I’ll link to this item from each week’s column so readers can find it easily.\">\n    <meta name=\"hdl\" content=\"FAQs on Style\">\n    <meta property=\"og:title\" content=\"FAQs on Style\">\n    <meta property=\"og:type\" content=\"article\">\n    <meta property=\"og:url\" content=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/\">\n    <meta property=\"og:site_name\" content=\"After Deadline Blog\">\n    <meta property=\"og:description\" content=\"Many topics come up repeatedly in reader comments and e-mail messages to After Deadline. Unfortunately I’m not able to offer a direct response to each comment (truth be told, After Deadline is a sideline for me). But one thoughtful reader suggested that I compile answers for some of the most common questions. Here’s a start in that effort. I’ll add other topics as they come up, and I’ll link to this item from each week’s column so readers can find it easily.\">\n    <meta property=\"og:image\" content=\"https://static01.nyt.com/images/blogs_v5/../icons/t_logo_291_black.png\">\n    <meta name=\"thumbnail_150\" content=\"https://static01.nyt.com/packages/images/icons/t_logo_300_black.png\">\n    <meta name=\"twitter:card\" value=\"summary\">\n    <meta name=\"twitter:title\" content=\"FAQs on Style\">\n    <meta name=\"twitter:url\" content=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/\">\n    <meta name=\"twitter:description\" content=\"Many topics come up repeatedly in reader comments and e-mail messages to After Deadline. Unfortunately I’m not able to offer a direct response to each comment (truth be told, After Deadline is a sideline for me). But one thoughtful reader suggested that I compile answers for some of the most common questions. Here’s a start in that effort. I’ll add other topics as they come up, and I’ll link to this item from each week’s column so readers can find it easily.\">\n    <meta name=\"twitter:image\" content=\"https://static01.nyt.com/packages/images/icons/t_logo_300_black.png\">\n    <meta itemprop=\"thumbnailUrl\" content=\"https://static01.nyt.com/packages/images/icons/t_logo_300_black.png\" name=\"thumbnail\">\n    <link rel=\"prev\" title=\"Words We Love Too Much\" href=\"//afterdeadline.blogs.nytimes.com/2010/04/06/words-we-love-too-much-4/\">\n    <link rel=\"next\" title=\"Danger! Danglers Everywhere!\" href=\"//afterdeadline.blogs.nytimes.com/2010/04/20/danger-danglers-everywhere/\">\n    <link rel=\"canonical\" href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/\">\n    <link rel=\"shortlink\" href=\"//nyti.ms/1QMXEMw\">\n    <link rel=\"https://github.com/WP-API/WP-API\" href=\"//afterdeadline.blogs.nytimes.com/json\">\n    <meta name=\"adxPage\" content=\"blog.nytimes.com/afterdeadline/post\">\n    <link rel=\"alternate\" type=\"application/rss+xml\" title=\"RSS 2.0\" href=\"//afterdeadline.blogs.nytimes.com/feed/\">\n    <meta property=\"article:collection\" content=\"https://static01.nyt.com/services/json/sectionfronts/most-emailed/index.jsonp\">\n    <link rel=\"alternate\" href=\"//mobile.nytimes.com/blogs/afterdeadline/2010/04/13/faqs-on-style/\">\n    <meta name=\"dfp-ad-unit-path\" content=\"timestopics/afterdeadline\">\n    <title>FAQs on Style - The New York Times</title>\n    <!--[if (gt IE 9)|!(IE)]> <!-->\n    <link rel=\"stylesheet\" type=\"text/css\" media=\"screen\" href=\"https://int.nyt.com/assets/blogs/latest/css/blogs/styles.css\">\n    <!--<![endif]-->\n    <!--[if lte IE 9]>\n    <link rel=\"stylesheet\" type=\"text/css\" media=\"screen\" href=\"https://int.nyt.com/assets/blogs/latest/css/blogs/styles-ie.css\" />\n<![endif]-->\n    <link rel=\"stylesheet\" type=\"text/css\" media=\"screen\" href=\"https://int.nyt.com/assets/blogs/latest/css/blogs/universal.css\">\n    <link rel=\"stylesheet\" type=\"text/css\" media=\"print\" href=\"https://int.nyt.com/assets/blogs/latest/css/blogs/styles-print.css\">\n    <script src=\"https://typeface.nyt.com/zam5nzz.js\" type=\"text/javascript\" async=\"\"></script><script>\n        var NYT = NYT || {},\n            NYTD = NYTD || {};\n    </script>\n    <script id=\"magnum-feature-flags\" type=\"application/json\">\n        [\"limitFabrikSave\", \"facebookOauthButton\", \"videoVHSCover\", \"videoVHSShareTools\", \"videoVHSEmbeddedOnly\", \"removeInternationalEdition\", \"piiBlockDFP\", \"indexAsHeaderBidder\", \"caslOpt\"]\n    </script>\n    <script>\n        var require = {\n            baseUrl: 'https://int.nyt.com/assets/',\n            waitSeconds: 20,\n            paths: {\n                'foundation': 'blogs/latest/js/foundation',\n                'blogs': 'blogs/latest/js/blogs',\n                'auth/mtr': 'https://static01.nyt.com/js/mtr',\n                'auth/growl': 'https://static01.nyt.com/js/auth/growl/default',\n            }\n        };\n    </script>\n    <!--[if (gte IE 9)|!(IE)]> <!-->\n    <script data-main=\"foundation/main\" src=\"https://int.nyt.com/assets/blogs/latest/js/foundation/lib/framework.js\"></script>\n    <!--<![endif]-->\n    <!--[if lt IE 9]>\n<script>\nrequire.map = { '*': { 'foundation/main': 'foundation/legacy_main' } };\n</script>\n<script data-main=\"foundation/legacy_main\" src=\"https://int.nyt.com/assets/blogs/latest/js/foundation/lib/framework.js\"></script>\n<![endif]-->\n    <script>\n        require(['foundation/main'], function() {\n            require(['auth/mtr']);\n        });\n    </script>\n    <!--esi\n<script id=\"user-info-data\" type=\"application/json\">\n<esi:include src=\"/svc/web-products/userinfo-v3.json\" />\n</script>\n-->\n<link id=\"legacy-zam5nzz\" rel=\"stylesheet\" type=\"text/css\" href=\"https://typeface.nyt.com/css/zam5nzz.css\" media=\"all\"><script type=\"text/javascript\" charset=\"utf-8\" async=\"\" data-requirecontext=\"_\" data-requiremodule=\"foundation/main\" src=\"https://int.nyt.com/assets/blogs/latest/js/foundation/main.js\"></script><script type=\"text/javascript\" charset=\"utf-8\" async=\"\" data-requirecontext=\"_\" data-requiremodule=\"foundation/hosts\" src=\"https://int.nyt.com/assets/blogs/latest/js/foundation/hosts.js\"></script><script type=\"text/javascript\" charset=\"utf-8\" async=\"\" data-requirecontext=\"_\" data-requiremodule=\"auth/mtr\" src=\"https://static01.nyt.com/js/mtr.js\"></script><script type=\"text/javascript\" charset=\"utf-8\" async=\"\" data-requirecontext=\"_\" data-requiremodule=\"blogs/main\" src=\"https://int.nyt.com/assets/blogs/latest/js/blogs/main.js\"></script><script type=\"text/javascript\" charset=\"utf-8\" async=\"\" data-requirecontext=\"_\" data-requiremodule=\"https://static01.nyt.com/projects/blogs/js/tracking.js\" src=\"https://static01.nyt.com/projects/blogs/js/tracking.js\"></script><script type=\"text/javascript\" charset=\"utf-8\" async=\"\" data-requirecontext=\"_\" data-requiremodule=\"blogs/legacy/common\" src=\"https://int.nyt.com/assets/blogs/latest/js/blogs/legacy/common.js\"></script><script type=\"text/javascript\" charset=\"utf-8\" async=\"\" data-requirecontext=\"_\" data-requiremodule=\"blogs/instances/liveupdates\" src=\"https://int.nyt.com/assets/blogs/latest/js/blogs/instances/liveupdates.js\"></script><script type=\"text/javascript\" charset=\"utf-8\" async=\"\" data-requirecontext=\"_\" data-requiremodule=\"foundation/views/ad-view-manager\" src=\"https://int.nyt.com/assets/blogs/latest/js/foundation/views/ad-view-manager.js\"></script></head>\n\n<body class=\"single single-post postid-88 blog-universal nyt-blog-afterdeadline\" data-env=\"production\" data-region=\"ewr1\"><div id=\"critical-alerts\" class=\"critical-alerts messenger\"><div id=\"account-alerts\" style=\"display: none; height: 0px;\" class=\"account-alerts alerts\"><div class=\"message-bed\"></div></div><div id=\"breaking-news-alerts\" style=\"display: none; height: 0px;\" class=\"breaking-news-alerts alerts\"><div class=\"message-bed\"></div></div></div><div id=\"suggestions\" style=\"display: none; height: 0px;\" class=\"suggestions messenger\"><div class=\"message-bed\"></div></div>\n    <div id=\"shell\" class=\"shell\">\n        <header id=\"masthead\" class=\"masthead masthead-theme-standard\" role=\"banner\">\n            <div class=\"container\"><div id=\"announcements\" style=\"display: none; width: 917px; left: 45px;\" class=\"announcements messenger\"><div class=\"message-bed\"></div></div>\n                <div class=\"quick-navigation button-group\">\n                    <button class=\"button sections-button\"><i class=\"icon sprite-icon\"></i><span class=\"button-text\">Sections</span></button>\n                    <button class=\"button home-button\" data-href=\"https://www.nytimes.com/\" title=\"Go to the home page to see the latest top stories.\"><i class=\"icon sprite-icon\"></i>\n                <span class=\"button-text\">Home</span>\n            </button>\n                    <button class=\"button search-button\"><i class=\"icon sprite-icon\"></i><span class=\"button-text\">Search</span></button>\n                    <a class=\"button skip-button skip-to-content visually-hidden focusable\" href=\"#main\">Skip to content</a>\n                </div>\n                <!-- close button-group -->\n                <div class=\"branding\">\n                    <h2 class=\"branding-heading\">\n                        <a id=\"branding-heading-link\" href=\"https://www.nytimes.com/\">\n                    <span class=\"visually-hidden\">The New York Times</span>\n                <svg class=\"nyt-logo\" width=\"185\" height=\"26\" role=\"img\" aria-label=\"The New York Times\"><image width=\"185\" height=\"26\" xlink:href=\"https://int.nyt.com/assets/blogs/latest/images/foundation/logos/nyt-logo-185x26.svg\" src=\"https://int.nyt.com/assets/blogs/latest/images/foundation/logos/nyt-logo-185x26.png\" alt=\"The New York Times\" border=\"0\"></image></svg><img src=\"https://int.nyt.com/assets/blogs/latest/images/foundation/logos/nyt-logo-185x26.png\" class=\"nyt-logo-print\" alt=\"The New York Times\"></a>\n                    </h2>\n                    <script>\n                        window.magnum.writeLogo('small', 'https://int.nyt.com/assets/blogs/latest/images/foundation/logos/', 'After Deadline', 'masthead-theme-standard', 'standard', 'branding-heading-link', 'blogs');\n                    </script>\n                </div>\n                <!-- close branding -->\n                <div class=\"story-meta\">\n                    <h6 class=\"kicker\">\n                        <span class=\"kicker-label\">\n\t\t\t            <a href=\"//afterdeadline.blogs.nytimes.com\">\n                After Deadline            </a>\n\t\t\t        </span>\n                        <span class=\"pipe\">|</span> FAQs on Style\n                    </h6>\n                </div>\n                <!-- close story-meta -->\n                <div class=\"user-tools\">\n                    <div id=\"sharetools-masthead\" class=\"sharetools theme-classic\" data-shares=\"email,facebook,twitter,show-all|More\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/\" data-title=\"FAQs on Style\" data-description=\"<span class=&quot;excerpt-inner&quot;>Many topics come up repeatedly in reader comments and e-mail messages to After Deadline. Unfortunately I’m not able to offer a direct response to each comment (truth be told, After Deadline is a sideline for me). But one thoughtful reader suggested that I compile answers for some of the most common questions. Here’s a start in that effort. I’ll add other topics as they come up, and I’ll link to this item from each week’s column so readers can find it easily.</span><a href=&quot;//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/&quot; class=&quot;more-link&quot;>Read&nbsp;more...</a>\" data-publish-date=\"April 13, 2010 3:08 pm\" data-share-tools-initialized=\"1\">\n                    <ul class=\"sharetools-menu\"><li class=\"sharetool email-sharetool\"><a href=\"javascript:;\" data-share=\"email\" data-modal-title=\"Log in to email\"><i class=\"icon sprite-icon\"></i><span class=\"sharetool-text \">Email</span></a></li><li class=\"sharetool facebook-sharetool\"><a href=\"javascript:;\" data-share=\"facebook\" data-modal-title=\"\"><i class=\"icon sprite-icon\"></i><span class=\"sharetool-text \">Share</span></a></li><li class=\"sharetool twitter-sharetool\"><a href=\"javascript:;\" data-share=\"twitter\" data-modal-title=\"\"><i class=\"icon sprite-icon\"></i><span class=\"sharetool-text \">Tweet</span></a></li><li class=\"sharetool show-all-sharetool\"><a href=\"javascript:;\" data-share=\"show-all\" data-modal-title=\"\"><i class=\"icon sprite-icon\"></i><span class=\"sharetool-text \">More</span></a></li></ul></div>\n                    <!-- close shareTools -->\n                    <button class=\"button search-button\"><i class=\"icon sprite-icon\"></i><span class=\"button-text\">Search</span></button>\n                    <div class=\"user-tools-button-group button-group\">\n                        <button class=\"button subscribe-button\" data-href=\"https://www.nytimes.com/subscriptions/Multiproduct/lp3004.html?campaignId=4XUYF\">Subscribe Now</button>\n                        <button class=\"button login-button login-modal-trigger\">Log In</button>\n                        <button class=\"button comments-button  button-masthead\" data-skip-to-para-id=\"\">\n<i class=\"icon\">\n\n<span class=\"button-text\">\n<span class=\"count\">120</span>\n\n</span>\n\n</i></button>\n                        <button class=\"button notifications-button hidden\"><i class=\"icon sprite-icon\"></i><span class=\"button-text\">0</span></button>\n                        <button class=\"button user-settings-button\"><i class=\"icon sprite-icon\"></i><span class=\"button-text\">Settings</span></button>\n                    </div>\n                    <!-- close user-tools-button-group -->\n                </div>\n                <!-- close user-tools -->\n            </div>\n            <!-- close container -->\n            <div class=\"search-flyout-panel flyout-panel\">\n                <button class=\"button close-button\" type=\"button\"><i class=\"icon\"></i><span class=\"visually-hidden\">Close search</span></button>\n                <nav class=\"search-form-control form-control layout-horizontal\">\n                    <h2 class=\"visually-hidden\">Site Search Navigation</h2>\n                    <form class=\"search-form\" role=\"search\">\n                        <div class=\"control\">\n                            <div class=\"label-container visually-hidden\">\n                                <label for=\"search-input\">Search NYTimes.com</label>\n                            </div>\n                            <div class=\"field-container\">\n                                <input id=\"search-input\" name=\"search-input\" type=\"text\" class=\"search-input text\" autocomplete=\"off\">\n                                <button type=\"button\" class=\"button clear-button\" tabindex=\"-1\" aria-describedby=\"clear-search-input\"><i class=\"icon\"></i><span id=\"clear-search-input\" class=\"visually-hidden\">Clear this text input</span></button>\n                                <div class=\"auto-suggest\" style=\"display: none;\">\n                                    <ol></ol>\n                                </div>\n                                <button class=\"button submit-button disabled\" type=\"submit\">Go</button>\n                            </div>\n                        </div>\n                        <!-- close control -->\n                    </form>\n                </nav>\n            </div>\n            <!-- close flyout-panel -->\n            <div id=\"notification-modals\" class=\"notification-modals\"></div>\n        </header>\n        <nav id=\"ribbon\" class=\"ribbon ribbon-start nocontent robots-nocontent\" aria-hidden=\"true\">\n            <div class=\"nocontent robots-nocontent\">\n                <ol class=\"ribbon-menu\" style=\"width: 7077px; left: 0px;\">\n                    <li class=\"collection news-collection\">\n\n<div class=\"collection-marker past-left-border\">\n<h2 class=\"collection-label\"><a href=\"https://www.nytimes.com\">Most Popular</a></h2>\n</div>\n\n<ol class=\"collection-menu\">\n<li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/18/opinion/sunday/covid-schools-reopen-teacher-safety.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/18/opinion/18Martinson/18Martinson-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n<h2 class=\"story-heading\">Please Don’t Make Me Risk Getting Covid-19 to Teach Your Child</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/18/us/politics/trump-coronavirus-response-failure-leadership.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/18/us/politics/18dc-virus-reconstruct1/18dc-virus-reconstruct1-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n<h2 class=\"story-heading\">Inside Trump’s Failure: The Rush to Abandon Leadership Role on the Virus</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/18/health/coronavirus-children-schools.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/18/science/18virus--kids/merlin_174135054_aed03bad-4e4b-4a8f-8ee7-b89113da5478-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n<h2 class=\"story-heading\">Older Children Spread the Coronavirus Just as Much as Adults, New Study Finds</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/15/magazine/white-fragility-robin-diangelo.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/19/magazine/19DiAngelo-mag1/19DiAngelo-mag1-thumbStandard-v3.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n\n<h3 class=\"kicker\">Feature</h3>\n<h2 class=\"story-heading\">‘White Fragility’ Is Everywhere. But Does Antiracism Training Work?</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/18/opinion/sunday/fauci-trump-coronavirus.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/19/opinion/19Dowd/19Dowd-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n<h2 class=\"story-heading\">Anthony Fauci Versus Donald Trump</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/17/us/john-lewis-dead.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/01/14/obituaries/14Lewis-John1-sub/14Lewis-John1-sub-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n<h2 class=\"story-heading\">John Lewis, Towering Figure of Civil Rights Era, Dies at 80</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/15/magazine/borrelia-miyamotoi-diagnosis.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/19/magazine/19mag-diagnosis-1/19mag-diagnosis-1-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n\n<h3 class=\"kicker\">Diagnosis</h3>\n<h2 class=\"story-heading\">She Tested Negative for Lyme Disease. So What Was Wrong?</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/13/travel/vermont-drone-photographs.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/13/travel/13travel-vermont-promo/13travel-vermont-promo-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n\n<h3 class=\"kicker\">The World Through a Lens</h3>\n<h2 class=\"story-heading\">Behold Vermont, From Above</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/16/opinion/sunday/coronavirus-blm-america-hope.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/20/opinion/sunday/20kristof/19kristof-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n<h2 class=\"story-heading\">Facing the Coronavirus and Racial Injustice, America Still Has Hope</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/15/realestate/Tips-bulbs-for-fall-planting-garden.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/13/realestate/15garden1/oakImage-1594675756166-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n\n<h3 class=\"kicker\">IN THE GARDEN</h3>\n<h2 class=\"story-heading\">Tips on Buying Bulbs for Fall Planting</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/17/opinion/portland-protests-federal-agents.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/17/opinion/17warzel1/17warzel1-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n<h2 class=\"story-heading\">50 Nights of Unrest in Portland</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/17/opinion/john-lewis.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/20/opinion/20LewisEditorial_v1/00LewisEditorial-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n<h2 class=\"story-heading\">John Lewis Risked His Life for Justice</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/16/opinion/police-funding-defund.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/16/opinion/16Hughes/16Hughes-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n<h2 class=\"story-heading\">I’m a Black Police Officer. Here’s How to Change the System.</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/17/opinion/coronavirus-family.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/17/opinion/17egan/17egan-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n<h2 class=\"story-heading\">Our Life Was Languid. Then My Daughter’s Family Moved In.</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/16/us/coronavirus-college-faculty-layoffs.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/16/us/16virus-collegelayoffs02-sub/merlin_171166869_86a2d73c-b1a8-420f-882d-d3e4f2e68991-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n<h2 class=\"story-heading\">As the Virus Deepens Financial Trouble, Colleges Turn to Layoffs</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/18/opinion/sunday/white-fragility-meritocracy.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/19/opinion/19Douthat/19Douthat-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n<h2 class=\"story-heading\">The Real White Fragility</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/18/us/portland-protests.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/18/us/18unrest-portland-1/merlin_174697392_435eafd8-b9c5-4edf-a542-9107c1d8e866-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n<h2 class=\"story-heading\">Federal Officers Deployed in Portland Didn’t Have Proper Training, D.H.S. Memo Said</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/18/opinion/republicans-keep-flunking-microbe-economics.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/18/opinion/18krugman2/18krugman2-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n<h2 class=\"story-heading\">With the Coronavirus Pandemic, Republicans Are Flunking Microbe Economics</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item  \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/15/magazine/gardening-made-me-happier-it-will-work-for-you-too.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/19/magazine/19eat/19eat-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n\n<h3 class=\"kicker\">Eat</h3>\n<h2 class=\"story-heading\">Gardening Made Me Happier. It Will Work for You Too.</h2>\n</article>\n</div>\n</a>\n</li><li class=\"collection-item last-collection-item \">\n<a class=\"story-link\" href=\"https://www.nytimes.com/2020/07/17/health/seniors-coronavirus-reopenings.html?rref=most-emailed\">\n<div class=\"story-container\">\n<article class=\"story theme-summary\">\n\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/21/science/17SCI-SPAN/17SCI-SPAN-thumbStandard.jpg\" alt=\"\">\n<div class=\"media-action-overlay\">\n\n<i class=\"icon sprite-icon image-icon\"></i>\n<span class=\"overlay-text visually-hidden\"></span>\n\n</div>\n</div>\n\n<h3 class=\"kicker\">The New Old Age</h3>\n<h2 class=\"story-heading\">You’re a Senior. How Do You Calculate Coronavirus Risk Right Now?</h2>\n</article>\n</div>\n</a>\n</li>\n</ol>\n</li><li class=\"collection ribbon-loader\">\n                        <div class=\"loader \"><span class=\"visually-hidden\">Loading...</span></div>\n                    </li>\n                </ol>\n                <div class=\"ribbon-navigation-container\">\n                    <nav class=\"ribbon-navigation next\">\n                        <span class=\"visually-hidden\">See next articles</span>\n                        <div class=\"arrow arrow-right\">\n                            <div class=\"arrow-conceal\"></div>\n                        </div>\n                    </nav>\n                    <nav class=\"ribbon-navigation previous inactive\">\n                        <span class=\"visually-hidden\">See previous articles</span>\n                        <div class=\"arrow arrow-left\">\n                            <div class=\"arrow-conceal\"></div>\n                        </div>\n                    </nav>\n                </div>\n            </div>\n            <!-- close nocontent -->\n        <div class=\"collection-marker first-collection-marker\">\n<h2 class=\"collection-label\"><a href=\"https://www.nytimes.com\">Most Popular</a></h2>\n</div></nav>\n        <nav id=\"navigation\" class=\"navigation\">\n            <h2 class=\"visually-hidden\">Site Navigation</h2>\n        <div class=\"sections\">\n\n\n<div class=\"section \">\n<ul class=\"menu\" role=\"menubar\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-A963B567-7D3D-4D0C-9E47-BF91609EFCE7\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com\">\nHome Page\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-9A43D8FC-F4CF-44D9-9B34-138D30468F8F\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/world\" aria-haspopup=\"true\" aria-expanded=\"false\">\nWorld\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-23FD6C8B-62D5-4CEA-A331-6C2A9A1223BE\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/us\" aria-haspopup=\"true\" aria-expanded=\"false\">\nU.S.\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-80E6DEE6-87E4-4AD0-9152-14FA6B07E5AB\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/politics\" aria-haspopup=\"true\" aria-expanded=\"false\">\nPolitics\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-C4DC8C0C-E148-4201-BF10-82F1C903DBFB\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/nyregion\" aria-haspopup=\"true\" aria-expanded=\"false\">\nN.Y.\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-104D1E63-9701-497B-8CF4-A4D120C9014E\" class=\"domestic expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/business\" aria-haspopup=\"true\" aria-expanded=\"false\">\nBusiness\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-A257D89A-0D3C-40AF-9C34-1A25A7947D94\" class=\"international \" role=\"menuitem\" href=\"https://www.nytimes.com/section/business\">\nBusiness\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-AD8090D7-4137-4D71-84C8-70DA3BD89778\" class=\"domestic expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/opinion\" aria-haspopup=\"true\" aria-expanded=\"false\">\nOpinion\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-09736473-CB3F-4B2F-9772-3AF128ABE12D\" class=\"international \" role=\"menuitem\" href=\"https://www.nytimes.com/section/opinion\">\nOpinion\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-78FBAD45-31A9-4EC7-B172-7D62A2B9955E\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/technology\" aria-haspopup=\"true\" aria-expanded=\"false\">\nTech\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-A4B35924-DB6C-4EA3-997D-450810F4FEE6\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/science\" aria-haspopup=\"true\" aria-expanded=\"false\">\nScience\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-7D6BE1AF-8CD8-430B-8B2A-17CD0EAA99AC\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/health\" aria-haspopup=\"true\" aria-expanded=\"false\">\nHealth\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-DE2B278B-2783-4506-AAD5-C15A5BB6DA1A\" class=\"domestic expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/sports\" aria-haspopup=\"true\" aria-expanded=\"false\">\nSports\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-BE66F420-C51B-461D-B487-CACF62E94AAE\" class=\"international \" role=\"menuitem\" href=\"https://www.nytimes.com/section/sports\">\nSports\n\n</a>\n</li>\n\n\n\n</ul>\n</div>\n\n<div class=\"section \">\n<ul class=\"menu\" role=\"menubar\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-C5BFA7D5-359C-427B-90E6-6B7245A6CDD8\" class=\"domestic expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/arts\" aria-haspopup=\"true\" aria-expanded=\"false\">\nArts\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-0202D0E4-C59B-479A-BD42-6F1766459781\" class=\"international \" role=\"menuitem\" href=\"https://www.nytimes.com/section/arts\">\nArts\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-7B052F64-13C5-4631-ACE4-F1BAA9706061\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/books\" aria-haspopup=\"true\" aria-expanded=\"false\">\nBooks\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-B3DFBD82-F298-43B3-9458-219B4F6AA2A5\" class=\"domestic expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/style\" aria-haspopup=\"true\" aria-expanded=\"false\">\nStyle\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-CC9E2674-F6C4-4A39-813B-F5AB0C515CEA\" class=\"international \" role=\"menuitem\" href=\"https://www.nytimes.com/section/style\">\nStyle\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-D9C94A2B-0364-4D25-8383-592CC66F82D4\" class=\"domestic expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/food\" aria-haspopup=\"true\" aria-expanded=\"false\">\nFood\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-FDEFB811-B483-4C3D-A25A-FD07BE5EAD96\" class=\"international \" role=\"menuitem\" href=\"https://www.nytimes.com/section/food\">\nFood\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-FDA10AC4-4738-4099-91E8-15584765C8D7\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/travel\">\nTravel\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-E57A148E-0CB9-4C02-966D-28B119710151\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/magazine\">\nMagazine\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-052C33AD-1404-4DB6-AA70-0901DB1AD95B\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/t-magazine\">\nT Magazine\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-92720057-BCB6-4BDB-9351-12F29393259F\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/realestate\" aria-haspopup=\"true\" aria-expanded=\"false\">\nReal Estate\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-CEDDB6A8-F7E1-47A2-AC53-E28C616DFCD5\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/obituaries\">\nObituaries\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-432A1823-3F24-43C0-8004-79088F94E754\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/video\" aria-haspopup=\"true\" aria-expanded=\"false\">\nVideo\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-D64FAE4C-4425-4E5A-B898-6C8CB59F9957\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/upshot\">\nThe Upshot\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-2745EC29-5385-40F2-93D4-F7E6EF3B518B\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/reader-center\">\nReader Center\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-0442C365-4B63-4B63-B9DE-3C28319CB622\" class=\" expandable\" role=\"menuitem\" tabindex=\"0\" aria-haspopup=\"true\" aria-expanded=\"false\">\nConferences\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n\n</ul>\n</div>\n\n<div class=\"section hidden\">\n<ul class=\"menu\" role=\"menubar\">\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-5C13EEDD-D905-4D8C-A284-6859EA434563\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/crosswords\">\nCrossword\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-99C17804-A343-4A76-BF04-F5793ADA48D1\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/reader-center\">\nTimes Insider\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-5B3E3370-B32C-42CD-8D7A-BD96736E3CD0\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/newsletters\">\nNewsletters\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-614CE30F-3D4A-4194-9C6F-AE5901C5762D\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/learning\">\nThe Learning Network\n\n</a>\n</li>\n\n\n\n</ul>\n</div>\n\n<div class=\"section hidden\">\n<ul class=\"menu\" role=\"menubar\">\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-8FB1308A-FFE4-4BED-ADF6-659A680D0884\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/multimedia\">\nMultimedia\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-108F7745-BAD9-4630-87BB-4FB4ED7CAA11\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/lens\">\nPhotography\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-EDCE4B29-2B91-4241-82E6-C972E9449F49\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/spotlight/podcasts\">\nPodcasts\n\n</a>\n</li>\n\n\n\n</ul>\n</div>\n\n<div class=\"section hidden\">\n<ul class=\"menu\" role=\"menubar\">\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-6101A43A-8BDE-45FF-AAD5-EF7396F83AC9\" class=\" \" role=\"menuitem\" href=\"https://store.nytimes.com/?action=click&amp;contentCollection=NYT%20Store&amp;contentPlacement=2&amp;module=SectionsNav&amp;pgtype=Homepage&amp;region=TopBar&amp;t=qry542&amp;utm_campaign=NYT-HP&amp;utm_content=hp_browsetree&amp;utm_medium=HPB&amp;utm_source=nytimes&amp;version=BrowseTree\">\nNYT Store\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-52A8A3F2-F138-425B-A63F-722E2BBC9372\" class=\" \" role=\"menuitem\" href=\"http://www.nytwineclub.com\">\nNYT Wine Club\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-081347DE-FF02-4B6C-889B-9AE59F391833\" class=\" \" role=\"menuitem\" href=\"http://nytedu.com\">\nnytEducation\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-797F8D17-1632-435D-B3DB-708FC4B4BAEF\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/times-journeys/?utm_source=nytimes&amp;utm_medium=HPLink&amp;utm_content=hp_browsetree&amp;utm_campaign=NYT-HP&amp;module=SectionsNav&amp;action=click&amp;region=TopBar&amp;version=BrowseTree&amp;contentCollection=Times%20Journeys&amp;contentPlacement=2&amp;pgtype=Homepage\">\nTimes Journeys\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-53CB229C-5F34-4C32-8B8C-6F7B7626BBDD\" class=\" \" role=\"menuitem\" href=\"https://www.chefd.com/pages/new-york-times-cooking-meal-plan?utm_campaign=web1_20160617&amp;utm_medium=partner&amp;utm_source=nyt\">\nMeal Kits\n\n</a>\n</li>\n\n\n\n</ul>\n</div>\n\n<div class=\"section hidden\">\n<ul class=\"menu\" role=\"menubar\">\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-FED853D9-D192-46F6-8D18-447803EB4A7B\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/seeallnav\">\nSubscribe\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-61E9BFEA-F509-4BCA-ADC6-32C5A30B83FD\" class=\" \" role=\"menuitem\" href=\"https://account.nytimes.com\">\nManage Account\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-0DAA7CFE-196B-4878-B899-5363070098EC\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/todayspaper\">\nToday's Paper\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-6BBF5308-5EA3-4B25-885F-393F7372F27F\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/marketing/tools-and-services/\">\nTools &amp; Services\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-288E1691-DA3B-457A-8B06-D10A1351E7B9\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/jobs\">\nJobs\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-D4C7C57A-E74D-44C3-9D0E-0AE6B715610F\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/ref/classifieds/\">\nClassifieds\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-6DD9D623-A907-4623-9C5A-9409972B76DA\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/corrections\">\nCorrections\n\n</a>\n</li>\n\n\n\n</ul>\n</div>\n\n<div class=\"section \">\n<ul class=\"menu\" role=\"menubar\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-more-section\" class=\" expandable\" role=\"menuitem\" tabindex=\"0\" aria-haspopup=\"true\" aria-expanded=\"false\">\nMore\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n\n</ul>\n</div>\n\n</div></nav>\n        <!-- close navigation -->\n        <nav id=\"mobile-navigation\" class=\"mobile-navigation hidden\">\n            <h2 class=\"visually-hidden\">Site Mobile Navigation</h2>\n        </nav>\n        <!-- close mobile-navigation -->\n        <div id=\"navigation-edge\" class=\"navigation-edge\"></div>\n        <main id=\"main\" class=\"main\" role=\"main\">\n            <div id=\"story\" class=\"story theme-main\">\n                <div id=\"afterdeadline\" class=\"spanAC blog\">\n                    <header id=\"blogs-masthead\" class=\"wrap\">\n                        <div class=\"ad sponsortile-ad hidden nocontent robots-nocontent\">\n                            <div class=\"caption\">Supported by</div>\n                        </div>\n                        <div class=\"element1\">\n                            <a href=\"//afterdeadline.blogs.nytimes.com/?module=BlogMain&amp;action=Click&amp;region=Header&amp;pgtype=Blogs&amp;version=Blog Post&amp;contentCollection=After Deadline\">\n                                <div id=\"logo\" class=\"archived-blog-post\">\n                                    <div class=\"w75 left site-header-logo\"><img src=\"https://static01.nyt.com/images/blogs_v3/afterdeadline/afterdeadline75.gif\" alt=\"After Deadline\"></div>\n                                    <div class=\"site-title\">After Deadline</div>\n                                    <div class=\"site-description\">New York Times Blog</div>\n                                </div>\n                            </a>\n                        </div>\n                        <div class=\"element2\">\n                            <div class=\"inlineSearchControl\">\n                                <form method=\"get\" id=\"searchform\" action=\"//afterdeadline.blogs.nytimes.com/\">\n                                    <input type=\"text\" value=\"\" name=\"s\" id=\"s\" class=\"text\" placeholder=\"Search After Deadline\">\n                                    <button type=\"submit\" class=\"searchsubmit\">Search</button>\n                                </form>\n                            </div>\n                        </div>\n                        <div class=\"clear\"></div>\n                    </header>\n                    <div class=\"a-column \" id=\"a-col\">\n                        <div id=\"content\" class=\"hfeed\">\n                            <article class=\"post-88 post type-post status-publish hentry category-times-topics tag-after-deadline tag-grammar\" id=\"post-88\">\n                                <header class=\"postHeader\">\n                                    <div class=\"postKicker\">\n                                    </div>\n                                    <h1 itemprop=\"headline\" class=\"entry-title\">FAQs on Style</h1>\n                                    <div class=\"story-meta-footer\">\n                                        <address class=\"byline author vcard\" itemprop=\"author creator\" itemtype=\"//schema.org/Person\">\n\t\t\t\tBy Philip B. Corbett\t\t\t</address>\n                                        <!-- date published --><time class=\"dateline \" datetime=\"2010-04-13T19:08:18+00:00\" itemprop=\"datePublished\">April 13, 2010 3:08 pm</time>\n                                        <!-- date updated --><span class=\"visually-hidden updated\">April 13, 2010 3:08 pm</span><button class=\"button comments-button  theme-kicker\" data-skip-to-para-id=\"\"><span class=\"button-meta\">\n<i class=\"icon\"></i>\n\n<span class=\"button-text\">\n<span class=\"count\">120</span>\n</span>\n\n</span></button>\n                                    </div>\n                                </header>\n                                <div class=\"entry-content\">\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>Notes from the newsroom on grammar, usage and style.</em></p>\n                                    <div>\n                                        <div class=\"standard190 left\"><em><img src=\"https://static01.nyt.com/images/blogs/topics/after_deadline190sub.jpg\" alt=\"AfterDeadline\"></em></div>\n                                    </div>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em> </em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Many topics come up repeatedly in reader comments and e-mail messages to After Deadline. Unfortunately I’m not able to offer a direct response to each comment (truth be told, After Deadline is a sideline for\n                                        me). But one thoughtful reader suggested that I compile answers for some of the most common questions.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Here’s a start in that effort. I’ll add other topics as they come up, and I’ll link to this item from each week’s column so readers can find it easily.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>[UPDATED on Nov. 14, 2011; newest item on top.]</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">•••</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>Why Do Plural Abbreviations Have an Apostrophe?</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">A number of readers have complained after seeing plural abbreviations like <em>M.D.’s</em> and <em>M.R.I.’s</em> in The Times. They say the apostrophe is wrong — that it indicates a possessive and\n                                        should not be used in a plural like this.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">In fact, style rules at The Times (and some other publications, including the Chicago Manual of Style) do call for using an apostrophe in the plural of abbreviations that include periods. The idea is that a combination\n                                        of uppercase letters, periods and a lowercase “s” is confusing at first glance, and that the apostrophe helps a reader see that the “s” has been added to make a plural.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Here’s the relevant portion of The Times’s stylebook entry:</p>\n                                    <blockquote>\n                                        <p class=\"story-body-text\" itemprop=\"articleBody\">Use apostrophes for plurals of abbreviations that have capital letters and periods: <em>M.D.’s, C.P.A.’s</em>. Also use apostrophes for plurals formed from single letters: He received <em>A’s and B’s on his report card. Mind your p’s and q’s</em>.</p>\n                                        <p class=\"story-body-text\" itemprop=\"articleBody\">But do not use apostrophes for plurals of abbreviations without periods, or for plurals formed from figures: <em>TVs, PCs, DVDs; 1990s, 747s, size 7s</em>.</p>\n                                    </blockquote>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>‘None': Singular or Plural?</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Should “none” be used with a singular or a plural verb?</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Some readers of The Times and After Deadline insist that “none” must always take a singular verb. They argue that “none” means “not one,” and so is inherently singular.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">But as I’ve pointed out before, most authorities, including The Times’s stylebook, disagree. Here’s our entry:<br>\n                                        <span id=\"more-88\"></span></p>\n                                    <blockquote>\n                                        <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>none</strong>. Despite a widespread assumption that it stands for <em>not one</em>, the word has been construed as a plural (<em>not any</em>) in most contexts for centuries. H. W. Fowler’s Dictionary\n                                            of Modern English Usage (1926) endorsed the plural use. Make <em>none</em> plural except when emphasizing the idea of <em>not one</em> or <em>no one</em> — and then consider using those phrases instead.\n                                        </p>\n                                    </blockquote>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>‘Like’ or ‘Such As’?</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">After <a href=\"//topics.blogs.nytimes.com/2010/08/31/the-trouble-with-like/\">a discussion</a> about the use of “like” as a conjunction, several commenters took issue with a different use of “like,”\n                                        including instances from The Times’s stylebook.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">These readers object to the use of “like” as a preposition to mean “including” or “as for example”: <em>Anyone else with an earned doctorate, <strong>like a Ph.D. degree</strong>, may request the title …</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">The objectors contend that “like” in this construction should mean “similar to” — so that this example, strictly speaking, would be referring to doctorates similar to a Ph.D. but not\n                                        including a Ph.D. They would change this phrase to “<strong>such as</strong> a Ph.D. degree.”</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Editors have long been divided on this point. But “like” is widely used, and recognized in all dictionaries, in the sense of “as for example.” Many writers find it more natural and less stilted\n                                        than “such as,” at least in some contexts.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Both versions seem acceptable to me; The Times’s stylebook tends to favor “like.”</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>Are Split Infinitives Acceptable?</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">The aversion to splitting infinitives is strongly held in some quarters, but weakly supported. Here’s what The Times’s stylebook says:</p>\n                                    <blockquote>\n                                        <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>split infinitives</strong> are accepted by grammarians but irritate many readers. When a graceful alternative exists, avoid the construction: <em>to show the difference clearly</em> is better than <em>to clearly show the difference</em>.\n                                            (Do not use the artificial <em>clearly to show the difference</em>.) When the split is unavoidable, accept it: <em>He was obliged to more than double the price</em>. Note, however, that compound verbs are an\n                                            unrelated issue: they should usually be separated (as this one was) when used with an adverb.</p>\n                                    </blockquote>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>Should a Sentence Ever Start With ‘And’? </strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">As I’ve noted before, another pet peeve of some After Deadline commenters is the use of “but” or “and” to begin a sentence. I don’t see any basis for their objections.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">It shouldn’t be overdone, but using coordinating conjunctions this way can provide a handy and very efficient transition. “But” is certainly preferable in many cases to the stilted “however,”\n                                        and “and” is simpler than “in addition” or similar phrases.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Along with the split-infinitive complaint, this objection falls into the category of “<a href=\"//topics.blogs.nytimes.com/2009/02/24/hobgoblins/\">Miss Thistlebottom’s hobgoblins</a>.” That’s\n                                        Theodore M. Bernstein’s term for the overly fastidious rules and usage myths a grade-school English teacher might invoke to keep her pupils’ prose on a very narrow path.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>Can a Person Be a ‘They’?</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">No. Miss Thistlebottom was right about this one. In careful writing, we continue to use “they” as a plural pronoun that should have a plural antecedent.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Often writers resort to “they” after a singular noun to avoid using a gender-specific pronoun in a general case. Here’s an example I cited in After Deadline last month:</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>When <strong>a person</strong> enters search terms for a product or service, the search engine may display links where <strong>they</strong> can get a discount coupon from a retailer or coupon aggregator.</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">In many cases, the problem can easily be avoided by starting with a plural noun: “When customers enter search terms …”</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>Is Data Singular or Plural?</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Yes.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">The Times’s stylebook allows “data” with either a plural or a singular verb. Here’s the entry:</p>\n                                    <blockquote>\n                                        <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>data</strong> is acceptable as a singular term for information: <em>The data was persuasive</em>. In its traditional sense, meaning a collection of facts and figures, the noun can still be plural: <em>They tabulate the data, which arrive from bookstores nationwide</em>.\n                                            (In this sense, the singular is <em>datum</em>, a word both stilted and deservedly obscure.)</p>\n                                    </blockquote>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">And here’s an earlier <a href=\"//topics.blogs.nytimes.com/2009/02/24/hobgoblins/\">After Deadline discussion</a> of this point, along with some other disputed points of usage.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>Where’s the Comma?</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Many readers complain about what they view as a missing comma in a sentence like this: <em>He bought apples, pears and bananas</em>.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Style guides for book and academic publishing generally would insist on another comma after “pears,” the so-called serial comma. But news writing has traditionally omitted the serial comma — perhaps\n                                        seeking a more rapid feeling in the prose, or perhaps to save time and effort in the old days of manual typesetting.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">We do use the additional comma in cases where a sentence would be awkward or confusing without it: <em>Choices for breakfast included oatmeal, muffins, and bacon and eggs</em>.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>Why Nascar, Not NASCAR?</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Auto racing fans chafe at our rules on acronyms. Here they are, from our stylebook:</p>\n                                    <blockquote>\n                                        <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>acronyms</strong>. An acronym is a word formed from the first letter (or letters) of each word in a series: <em>NATO</em> from <em>N</em>orth <em>A</em>tlantic <em>T</em>reaty <em>O</em>rganization; <em>radar</em>                                            from <em>ra</em>dio <em>d</em>etection <em>a</em>nd <em>r</em>anging. (Unless pronounced as a word, an abbreviation is not an acronym.) When an acronym serves as a proper name and exceeds four letters, capitalize\n                                            only the first letter: <em>Unesco; Unicef</em>.</p>\n                                    </blockquote>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">We limit the uppercasing to four letters because longer strings of capitals are distracting and tend to jump off the page.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>One of Those Things</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">To my surprise, many readers insist that I’m wrong to call for a plural verb in sentences like this: <em>He is one of those teachers who <strong>refuse</strong> to allow laptops in class</em>.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">I don’t necessarily expect to win over the doubters, but I’m not budging. Here’s a <a href=\"//topics.blogs.nytimes.com/2009/12/15/one-of-those-things/\">more detailed explanation</a> from a previous\n                                        post.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>Who’s a Dr.?</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Our continued use of courtesy titles — increasingly rare in the news media — prompts many questions. Rules on the use of “Dr.” in particular can lead to confusion, for readers and unfortunately\n                                        sometimes for our writers. Here’s our stylebook entry:</p>\n                                    <blockquote>\n                                        <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>Dr.</strong> should be used in all references for physicians and dentists whose practice is their primary current occupation, or who work in a closely related field, like medical writing, research or pharmaceutical\n                                            manufacturing: <em>Dr. Alex E. Baranek; Dr. Baranek; the doctor</em>. (Those who practice only incidentally, or not at all, should be called <em>Mr., Ms., Miss</em> or <em>Mrs</em>.)</p>\n                                        <p class=\"story-body-text\" itemprop=\"articleBody\">Anyone else with an earned doctorate, like a Ph.D. degree, may request the title, but only if it is germane to the holder’s primary current occupation (academic, for example, or laboratory research). For\n                                            a Ph.D., the title should appear only in second and later references. The holder of a Ph.D. or equivalent degree may also choose not to use the title.</p>\n                                        <p class=\"story-body-text\" itemprop=\"articleBody\">Do not use the title for someone whose doctorate is honorary.</p>\n                                    </blockquote>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>Stodgy Traditionalist or Permissive Panderer?</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">I take no sides in the philosophical debate between descriptivists and prescriptivists on usage questions. As I explained in <a href=\"//topics.blogs.nytimes.com/2009/05/05/rules-and-the-editor/\">this post last year</a>,\n                                        I’m just a newspaper editor. My goal is lucid prose that is polished and literate without being stuffy.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>‘After Deadline’ Correspondence</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">I read the comments that are posted each week, which frequently give me ideas or fodder for future installments. You can also send e-mail messages to nytnews@nytimes.com; please put “After Deadline” in\n                                        the subject line so the message will be forwarded to me.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>Can I Get The Times’s Stylebook?</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">The print edition of “<a href=\"//www.amazon.com/York-Times-Manual-Style-Usage/dp/081296389X\">The New York Times Manual of Style and Usage</a>,” written by two esteemed former colleagues, Allan M. Siegal\n                                        and William G. Connolly, can still be bought online and in some bookstores.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">I oversee an online version that includes many changes and updates since the book’s publication in 1999. Unfortunately that version is not accessible to the public, though we have discussed the possibility of\n                                        making it available in some form.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>Is It Daylight Saving Time Again?</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Some readers complain that the After Deadline logo looks too much like the clock we publish to remind people of the time change.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">I didn’t devise the logo, of course. We actually use a different one for the in-house version — a thick red pencil line circling the title, like an editor’s mark. It was deemed a bit too old-fashioned\n                                        for the online edition, I believe. In any case, if it’s not March or November, assume that the clock means After Deadline.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">•••</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><strong>In a Word</strong></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">This week’s grab bag of grammar, style and other missteps, compiled with help from colleagues and readers.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">•••</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>DETROIT — The Transportation Department <strong>said Monday it would seek</strong> a $16.4 million fine against Toyota, the largest allowed, because the company had failed to promptly notify the government about potential problems with accelerator pedals.</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Don’t omit “that” after a time element in a construction like this.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">•••</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>Rescuers [in China] knocked on and shouted into the pipe, and they sent down glucose, a phone, pen, paper and letters of encouragement inside a plastic bottle.</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>“Dear fellow workers, the Party Central Committee, the State Council and the whole nation have been concerned for your safety,” one began. It ended: “Hold <strong>onto</strong> the last.”</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">This is presumably a translation; it should be grammatically correct. Make it “Hold on to the last” — “on” is an adverb that goes with “hold.”</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">•••</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>[Online caption] A harp seal pup <strong>lays</strong> on the ice in 2008 near Charlottetown, Prince Edward Island.</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">“Lies,” of course. Or if we want past tense, make it “lay.”</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">•••</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>The characters, including the inevitably valiant warriors who <strong>aide</strong> Perseus during his computer-assisted adventures, are as predictable as the action scenes, which is what some companies want when they manufacture global products of this type.</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Make it “aid,” not “aide.”</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">•••</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>But it does not appear that the foundation has addressed how Ms. Harris, <strong>going forward,</strong> would keep her roles from overlapping.</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">A colleague notes that this phrase is usually redundant. We should avoid it, going forward, in the future. (Also, I see no reason for “would”; make it “will keep.”)</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">•••</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>Sheila Stainback, a city housing authority spokeswoman, said Morrisania Air Rights was <strong>thusly</strong> named because it was built above Metro-North train tracks, but she was not immediately sure about the “why.”</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">“Thus” is an adverb; thus, there is no call to add “ly.” In any case, “so named” would probably be better here.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">•••</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>Weak Rules on <strong>Toxins</strong> and Safety</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>Nobody can be sure, though. The science is not far enough along, partly because our regulation of <strong>toxins</strong> is so limp.</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">As we noted here not long ago, “toxin,” properly used, refers to a plant or animal poison. In this column, we meant “toxic chemicals” or something like that.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">•••</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>M. Sunil Kumar was a 25-year-old reporter at a local newspaper in the provincial town of Warangal. His older brother Anil had dropped out of high school to run the family’s mutton shop <strong>when their father died so that Sunil could go to college</strong>.</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Watch where you put that clause. The father, of course, did not die so that Sunil could go to college.</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">•••</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>Yesterday, Decoder came across a rare <strong>site</strong> in the wilds of Manhattan: A happy publishing executive.</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">Even for a blog post, this was a little <em>too</em> Web-oriented; make it “sight.”</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">•••</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>While speaking to television writers in January, Mr. Sutherland said of the torture sequences: “It’s a television show. We’re not telling you to try this at home.”</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>He also <strong>refuted</strong> claims of a political slant to “24.” “One of the things that I was always so unbelievably proud of our show is that you could have it being discussed by former President Bill Clinton and Rush Limbaugh at the same time, both using it and citing it to justify their points of view,” he said. “That, to me, was incredibly balanced.”</em></p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">In careful usage, “refute” means to prove something false, not merely to offer a counterargument. Here, we needed something like “rebut,” “reject” or “deny.”</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\">•••</p>\n                                    <p class=\"story-body-text\" itemprop=\"articleBody\"><em>After Deadline examines questions of grammar, usage and style encountered by writers and editors of The Times. It is adapted from a weekly newsroom critique overseen by <a href=\"//www.nytimes.com/2007/10/29/business/media/29asktheeditors.html\">Philip B. Corbett</a>, the associate managing editor for standards, who is also in charge of The Times’s style manual.</em></p>\n                                </div>\n                                <footer class=\"entry-footer\">\n                                    <button class=\"button comments-button theme-speech-bubble\">\n<i class=\"icon\">\n\n<span class=\"button-text\">\n<span class=\"count\">120</span>\n\n<span class=\"units\">Comments</span>\n\n</span>\n\n</i></button>\n                                    <div id=\"sharetools-post-footer\" class=\"sharetools theme-classic\" data-shares=\"show-all|Share\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/\" data-title=\"FAQs on Style\" data-description=\"Many topics come up repeatedly in reader comments and e-mail messages to After Deadline. Unfortunately I’m not able to offer a direct response to each comment (truth be told, After Deadline is a sideline for me). But one thoughtful reader suggested that I compile answers for some of the most common questions. Here’s a start in that effort. I’ll add other topics as they come up, and I’ll link to this item from each week’s column so readers can find it easily.\" data-share-tools-initialized=\"1\">\n                                    <ul class=\"sharetools-menu\"><li class=\"sharetool show-all-sharetool\"><a href=\"javascript:;\" data-share=\"show-all\" data-modal-title=\"\"><i class=\"icon sprite-icon\"></i><span class=\"sharetool-text \">Share</span></a></li></ul></div>\n                                    <div class=\"footer-tags\">\n                                    </div>\n                                </footer>\n                            </article>\n                            <section id=\"whats-next\" class=\"whats-next nocontent robots-nocontent\">\n                                <h2 class=\"visually-hidden\">What's Next</h2>\n                                <div class=\"nocontent robots-nocontent\">\n                                    <div class=\"loader-container\">\n                                        <div class=\"loader loader-t-logo-32x32-ecedeb-ffffff\"><span class=\"visually-hidden\">Loading...</span></div>\n                                    </div>\n                                </div>\n                                <!-- close nocontent -->\n                            </section>\n                        </div>\n                        <!-- end content -->\n                    </div>\n                    <!-- end .a-column -->\n                    <div class=\"cColumn nocontent robots-nocontent\">\n                        <aside>\n                            <div class=\"postNavigation\">\n                                <ul class=\"opposingFloatControl wrap\">\n                                    <li class=\"element1\">\n                                        <span class=\"previous\">Previous Post</span>\n                                        <div class=\"arrow arrow-left\">\n                                            <div class=\"arrow-conceal\"></div>\n                                        </div>\n                                        <a class=\"postTitle\" href=\"//afterdeadline.blogs.nytimes.com/2010/04/06/words-we-love-too-much-4/\" title=\"Words We Love Too Much\">\n\t\t\t\tWords We Love Too Much\t\t\t</a>\n                                    </li>\n                                    <li class=\"element2\">\n                                        <span class=\"next\">Next Post</span>\n                                        <div class=\"arrow arrow-right\">\n                                            <div class=\"arrow-conceal\"></div>\n                                        </div>\n                                        <a class=\"postTitle\" href=\"//afterdeadline.blogs.nytimes.com/2010/04/20/danger-danglers-everywhere/\" title=\"Danger! Danglers Everywhere!\">\n\t\t\t\tDanger! Danglers Everywhere!\t\t\t</a>\n                                    </li>\n                                </ul>\n                            </div>\n                            <div id=\"nyt_about_blog-3\" class=\"module nocontent widget_nyt_about_blog\">\n                                <h4 class=\"moduleHeader\">About</h4>\n                                <div class=\"entry\">\n                                    <img class=\"w151 right\" src=\"https://static01.nyt.com/images/blogs/topics/grammar-165.jpg\">\n                                    <p></p>\n                                    <p class=\"summary\">After Deadline examines questions of grammar, usage and style encountered by writers and editors of The Times. It is adapted from a weekly newsroom critique overseen by Philip B. Corbett, the associate managing editor\n                                        for standards, who is also in charge of The Times’s style manual.</p>\n                                    <ul class=\"refer\">\n                                        <li><a href=\"//afterdeadline.blogs.nytimes.com/2015/06/23/faqs-on-style-2/\" title=\"FAQs on Style\">FAQs on Style</a></li>\n                                    </ul>\n                                </div>\n                            </div>\n                            <div class=\"module archivesModule clearfix nocontent\">\n                                <h4 class=\"moduleHeader\">Archive</h4> <select name=\"archive_chrono\" onchange=\"window.location.href=this.value; this.selectedIndex=this.options[0]\">\n\t\t\t\t<option class=\"archiveform_option\" value=\"\">Select Month</option>\n\t\t\t\t\t<option value=\"//afterdeadline.blogs.nytimes.com/2016/03/\"> March 2016 </option>\n\t<option value=\"//afterdeadline.blogs.nytimes.com/2016/02/\"> February 2016 </option>\n\t<option value=\"//afterdeadline.blogs.nytimes.com/2016/01/\"> January 2016 </option>\n\t<option value=\"//afterdeadline.blogs.nytimes.com/2015/12/\"> December 2015 </option>\n\t<option value=\"//afterdeadline.blogs.nytimes.com/2015/11/\"> November 2015 </option>\n\t<option value=\"//afterdeadline.blogs.nytimes.com/2015/10/\"> October 2015 </option>\n\t<option value=\"//afterdeadline.blogs.nytimes.com/2015/09/\"> September 2015 </option>\n\t<option value=\"//afterdeadline.blogs.nytimes.com/2015/08/\"> August 2015 </option>\n\t<option value=\"//afterdeadline.blogs.nytimes.com/2015/07/\"> July 2015 </option>\n\t<option value=\"//afterdeadline.blogs.nytimes.com/2015/06/\"> June 2015 </option>\n\t<option value=\"//afterdeadline.blogs.nytimes.com/2015/05/\"> May 2015 </option>\n\t<option value=\"//afterdeadline.blogs.nytimes.com/2015/04/\"> April 2015 </option>\n\t<option value=\"//afterdeadline.blogs.nytimes.com/2015/03/\"> March 2015 </option>\n\t<option value=\"//afterdeadline.blogs.nytimes.com/2015/02/\"> February 2015 </option>\n\t<option value=\"//afterdeadline.blogs.nytimes.com/2015/01/\"> January 2015 </option>\n\t\t\t</select>\n                            </div>\n                            <div id=\"recentposts-2\" class=\"module nocontent widget_recentposts\">\n                                <h4 class=\"moduleHeader\">Recent Posts</h4>\n                                <div class=\"entry\">\n                                    <h5><a href=\"//afterdeadline.blogs.nytimes.com/2016/03/22/a-lineup-of-missteps-8/\" title=\"Read: A Lineup of Missteps\">A Lineup of Missteps</a>\n                                        <span class=\"postMetaHeaderCommentCount commentCount hidden\">\n\t\t\t\t\t<i class=\"icon\"></i>\n\t\t\t\t\t<a class=\"commentCountLink commentCountNumberOnly commentCountNoPrompt\" href=\"//afterdeadline.blogs.nytimes.com/2016/03/22/a-lineup-of-missteps-8/\"></a>\n\t\t\t\t</span> </h5>\n                                    <p class=\"summary\">\n                                        This week’s grab bag of grammar, style and other missteps, compiled with help from colleagues and readers.<a href=\"//afterdeadline.blogs.nytimes.com/2016/03/22/a-lineup-of-missteps-8/\" class=\"more-link\">Read&nbsp;more…</a></p>\n                                </div>\n                                <div class=\"entry\">\n                                    <h5><a href=\"//afterdeadline.blogs.nytimes.com/2016/03/15/close-but-not-quite-14/\" title=\"Read: Close but Not Quite\">Close but Not Quite</a>\n                                        <span class=\"postMetaHeaderCommentCount commentCount hidden\">\n\t\t\t\t\t<i class=\"icon\"></i>\n\t\t\t\t\t<a class=\"commentCountLink commentCountNumberOnly commentCountNoPrompt\" href=\"//afterdeadline.blogs.nytimes.com/2016/03/15/close-but-not-quite-14/\"></a>\n\t\t\t\t</span> </h5>\n                                    <p class=\"summary\">\n                                        We think we know what these words mean. We almost know what they mean. But we don’t, not quite. Here are some recent examples of mixed-up words and homophone trouble.<a href=\"//afterdeadline.blogs.nytimes.com/2016/03/15/close-but-not-quite-14/\" class=\"more-link\">Read&nbsp;more…</a></p>\n                                </div>\n                                <div class=\"entry\">\n                                    <h5><a href=\"//afterdeadline.blogs.nytimes.com/2016/03/08/ugly-disagreements-4/\" title=\"Read: Ugly Disagreements\">Ugly Disagreements</a>\n                                        <span class=\"postMetaHeaderCommentCount commentCount hidden\">\n\t\t\t\t\t<i class=\"icon\"></i>\n\t\t\t\t\t<a class=\"commentCountLink commentCountNumberOnly commentCountNoPrompt\" href=\"//afterdeadline.blogs.nytimes.com/2016/03/08/ugly-disagreements-4/\"></a>\n\t\t\t\t</span> </h5>\n                                    <p class=\"summary\">\n                                        We should all be able to agree that singular subjects need singular verbs and plural subjects need plural verbs. Upholding that rule on deadline, however, continues to be a challenge. Here is the latest sampling of singular/plural tribulations.\n                                        <a href=\"//afterdeadline.blogs.nytimes.com/2016/03/08/ugly-disagreements-4/\" class=\"more-link\">Read&nbsp;more…</a>\n                                    </p>\n                                </div>\n                                <div class=\"entry\">\n                                    <h5><a href=\"//afterdeadline.blogs.nytimes.com/2016/03/01/a-lineup-of-missteps-7/\" title=\"Read: A Lineup of Missteps\">A Lineup of Missteps</a>\n                                        <span class=\"postMetaHeaderCommentCount commentCount hidden\">\n\t\t\t\t\t<i class=\"icon\"></i>\n\t\t\t\t\t<a class=\"commentCountLink commentCountNumberOnly commentCountNoPrompt\" href=\"//afterdeadline.blogs.nytimes.com/2016/03/01/a-lineup-of-missteps-7/\"></a>\n\t\t\t\t</span> </h5>\n                                    <p class=\"summary\">\n                                        This week’s extra-large grab bag of grammar, style and other missteps from recent articles.<a href=\"//afterdeadline.blogs.nytimes.com/2016/03/01/a-lineup-of-missteps-7/\" class=\"more-link\">Read&nbsp;more…</a></p>\n                                </div>\n                                <div class=\"entry\">\n                                    <h5><a href=\"//afterdeadline.blogs.nytimes.com/2016/02/23/bright-passages-28/\" title=\"Read: Bright Passages\">Bright Passages</a>\n                                        <span class=\"postMetaHeaderCommentCount commentCount hidden\">\n\t\t\t\t\t<i class=\"icon\"></i>\n\t\t\t\t\t<a class=\"commentCountLink commentCountNumberOnly commentCountNoPrompt\" href=\"//afterdeadline.blogs.nytimes.com/2016/02/23/bright-passages-28/\"></a>\n\t\t\t\t</span> </h5>\n                                    <p class=\"summary\">\n                                        Here’s a short break from carping, and another sampling of sparkling prose from recent Times stories.<a href=\"//afterdeadline.blogs.nytimes.com/2016/02/23/bright-passages-28/\" class=\"more-link\">Read&nbsp;more…</a></p>\n                                </div>\n                            </div>\n                            <!-- end Recent Posts side tool -->\n                            <div id=\"nyt_promo_widget-3\" class=\"module nocontent widget_nyt_promo_widget\">\n                                <h4 class=\"moduleHeader\">Subscribe to After Deadline RSS Feed</h4><a href=\"//afterdeadline.blogs.nytimes.com/feed/\" class=\"icon\"><img src=\"https://static01.nyt.com/images/global/icons/rss.gif\" alt=\"After Deadline RSS Feed\" width=\"44\" height=\"16\" border=\"0\" align=\"absmiddle\"></a></div>\n                        </aside>\n                    </div>\n                    <div class=\"clear\"></div>\n                </div>\n                <!-- end blog wrap -->\n                <div class=\"hideContent\"></div>\n                <div id=\"SponLink\" class=\"text-ad bottom-left-ad nocontent robots-nocontent\"></div>\n            <div class=\"comments-panel\" style=\"display: none;\"><div class=\"panel-controls\">\n<button class=\"button close-panel-button\">\n<i class=\"icon\"></i><span class=\"visually-hidden\">Close this panel</span>\n</button>\n</div>\n<div class=\"panel-content\"><section id=\"comments\" class=\"comments\" tabindex=\"1\">\n<div class=\"comment-permalink-view\" style=\"display: none;\">\n</div>\n<div class=\"comments-header-container\">\n<header class=\"comments-header\">\n<div id=\"Spon2\" class=\"ad comments-tile-ad\"></div>\n<h2 class=\"section-heading\" tabindex=\"1\"><i class=\"icon comments-icon\"></i>120 Comments</h2>\n\n\n<p class=\"comments-status\">The comments section is closed. To submit a letter to the editor for publication, write to <a href=\"mailto:letters@nytimes.com\">letters@nytimes.com</a>. </p>\n\n</header>\n<div class=\"comment-form-control form-control thread-form active\"></div>\n<div class=\"comments-view-navigation\">\n<div class=\"tabs-container\">\n<ul class=\"tabs\">\n\n<li class=\"tab all selected\" data-filter=\"all\" tabindex=\"5\">All<span class=\"count\" data-filter=\"all\">&nbsp;120</span></li>\n\n</ul>\n</div>\n<div class=\"comments-sort-container\">\n<div class=\"comments-sort\" tabindex=\"5\">Newest</div><i class=\"icon\"></i>\n</div>\n</div>\n</div>\n<div class=\"comments-view tab-content\" tabindex=\"50\">\n\n\n<article class=\"comment   \" data-id=\"15411251\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=15411251\" data-parentid=\"0\" data-sequence=\"15411251\" data-permid=\"15411251\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Adam Sinclair</h3>\n\n\n<span class=\"commenter-location\">Israel</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=15411251\" class=\"comment-time\" datetime=\"\">July 7, 2015</a>\n</header>\n<p class=\"comment-text\">\"But do not use apostrophes for plurals of abbreviations without periods, or for plurals formed from figures: TVs, PCs, DVDs; 1990s, 747s, size 7s.\"  What about if the abbreviation in question ends in an 's'?  At my job, we have a product called an RMS and I struggle with how to pluralize it.  RMS's or RMSes?</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"14985864\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=14985864\" data-parentid=\"0\" data-sequence=\"14985864\" data-permid=\"14985864\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Dan</h3>\n\n\n<span class=\"commenter-location\">Eearth</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=14985864\" class=\"comment-time\" datetime=\"\">May 19, 2015</a>\n</header>\n<p class=\"comment-text\">In the case of: <br><br>\" ... doctorate, like a Ph.D., ...\"<br><br>The phrase is clearly set off as non-restrictive.  This makes the meaning of \"like\" here 100% unmistakable.  There is no problem.  As a side note, without the the commas \"such as\" would be quite confusing.  The complainers here are applying arbitrary moral absolutes of some cult grammar religion instead of actually thinking about the sentence. I am saying this as someone who hates to see useful linguistic elements become permanently neutered by ambiguous popular misuse.   Breaking someone's rules though and creating ambiguity are not the same thing.</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"14379244\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=14379244\" data-parentid=\"0\" data-sequence=\"14379244\" data-permid=\"14379244\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Vali Jamal</h3>\n\n\n<span class=\"commenter-location\">Uganda</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=14379244\" class=\"comment-time\" datetime=\"\">March 13, 2015</a>\n</header>\n<p class=\"comment-text\">About the use of an apostrophe s after initials - M.D.'s. Fair enough, but isn't it time to do away with the periods? Can you not say MDs, PhDs. For a member of parliament what's your style - M.P. or MP and the plural MPs. In UK style they have given up on periods even after initials and I agree. Periods only make you stop. </p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n<div class=\"thread\"><article class=\"comment threaded-comment  \" data-id=\"14985868\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=14985868\" data-parentid=\"14379244\" data-sequence=\"14985868\" data-permid=\"14985868\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Dan</h3>\n\n\n<span class=\"commenter-location\">Eearth</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=14985868\" class=\"comment-time\" datetime=\"\">May 19, 2015</a>\n</header>\n<p class=\"comment-text\">Even so, many styles even use apostrophes for the non-period-ed ;) versions too. That doesn't negate your point though.</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article></div>\n\n\n</article><article class=\"comment   \" data-id=\"13703599\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=13703599\" data-parentid=\"0\" data-sequence=\"13703599\" data-permid=\"13703599\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">pete</h3>\n\n\n<span class=\"commenter-location\">Piedmont Calif.</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=13703599\" class=\"comment-time\" datetime=\"\">January 20, 2015</a>\n</header>\n<p class=\"comment-text\"><br>12/30/2104<br><br>\"...Representative Steve Scalise of Louisiana, the No. 3 Republican in the House, confirmed that a dozen years ago he addressed a group of white supremacists\"<br><br>What value is added by writing \"a dozen years\"  instead of \"twelve years\"?<br>Eggs are sold by the dozen.  to say \" a dozen years\"   sounds like you are trying to be cute.  This is not the place for cuteness.  <br><br>However, I did note today that in an op-ed piece about the Greek economy, you actually said that someone's salary had changed  \" 'from' so much 'to' a lesser amount \"    rather than your usual Yoda-like way of backwards everything saying.</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"13486913\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=13486913\" data-parentid=\"0\" data-sequence=\"13486913\" data-permid=\"13486913\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">KTM</h3>\n\n\n<span class=\"commenter-location\">Boston</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=13486913\" class=\"comment-time\" datetime=\"\">December 9, 2014</a>\n</header>\n<p class=\"comment-text\">Database constraints have affected time and date presentations in all lists of events. Please comment on the best online style for dates and times (AM PM. closed up to numerals, or a.m. p.m. with preceding spaces. Periods, spacing, and month abbreviations are now inconsistent in online presentations.</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"12990614\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=12990614\" data-parentid=\"0\" data-sequence=\"12990614\" data-permid=\"12990614\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Rebecca</h3>\n\n\n<span class=\"commenter-location\">New York, NY</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=12990614\" class=\"comment-time\" datetime=\"\">October 7, 2014</a>\n</header>\n<p class=\"comment-text\">The word \"deep\" has been overused in the past year in the paper, along with \"deeply.\"  Please find another word to use!</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"11289173\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=11289173\" data-parentid=\"0\" data-sequence=\"11289173\" data-permid=\"11289173\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">kgfgh</h3>\n\n\n<span class=\"commenter-location\">kgfgh</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=11289173\" class=\"comment-time\" datetime=\"\">March 7, 2014</a>\n</header>\n<p class=\"comment-text\">Having a little trouble convincing the Times that those pesky dangling and misplaced modifiers are rampant?<br>Today, March 6th Front page of the online NY Times:<br>\"Private Lives<br>Snow Mania<br>By HAIMING XU<br>Growing up hungry in rural China in the 1970s, rice, white crystalline rice, was the stuff of dreams.\"<br>Somehow, I doubt that crystalline rice grew up hungry.  While the article's author, whose native language is Chinese, may be forgiven, the Times may not!</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \"><span class=\"recommend-count\"><i class=\"icon sprite-icon\"></i>2</span>Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"11271865\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=11271865\" data-parentid=\"0\" data-sequence=\"11271865\" data-permid=\"11271865\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Jackie Treehorn</h3>\n\n\n<span class=\"commenter-location\">New Mexico</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=11271865\" class=\"comment-time\" datetime=\"\">March 4, 2014</a>\n</header>\n<p class=\"comment-text\">What's the rule on the \"not un-\" formation? I see it all over the NYT. (Just now, for example, in Carl Hulse's article on Mitch McConnell. \"It is not inconceivable...\") Why do not unprofessional writers use such not unawkward phrasing when it's never not unnecessary?</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \"><span class=\"recommend-count\"><i class=\"icon sprite-icon\"></i>2</span>Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"11154660\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=11154660\" data-parentid=\"0\" data-sequence=\"11154660\" data-permid=\"11154660\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">VPM</h3>\n\n\n<span class=\"commenter-location\">Houston Tx</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=11154660\" class=\"comment-time\" datetime=\"\">February 18, 2014</a>\n</header>\n<p class=\"comment-text\">In the article on nightstands in the 13 Feb online edition : \"The cabinets in question fit all that criteria…\"  Please, please, please criterion/criteria have not yet gone down the path of datum/data.  Criteria is a PLURAL noun, and the singular is criterion.  Where are the editors?</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"10700938\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=10700938\" data-parentid=\"0\" data-sequence=\"10700938\" data-permid=\"10700938\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Bernard Farrell</h3>\n\n\n<span class=\"commenter-location\">North Of Boston,  MA</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=10700938\" class=\"comment-time\" datetime=\"\">December 10, 2013</a>\n</header>\n<p class=\"comment-text\">These style rules seem very useful. Are they available online?</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"9948532\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=9948532\" data-parentid=\"0\" data-sequence=\"9948532\" data-permid=\"9948532\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">inverseio</h3>\n\n\n<span class=\"commenter-location\">Memphis TN</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=9948532\" class=\"comment-time\" datetime=\"\">September 12, 2013</a>\n</header>\n<p class=\"comment-text\">But if \"you’re a member of Congress or a senator\" who’s still wondering whether to grant President Obama the authority to use force to deter Syrian President Bashar al-Assad from again murdering hundreds of his people with poison gas, it now makes sense to take a timeout.<br><br>This is from an article in today's paper.  Could the section in question be better phrased as a senator is a member of Congress?</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"9919727\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=9919727\" data-parentid=\"0\" data-sequence=\"9919727\" data-permid=\"9919727\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Julio Kuplinsky</h3>\n\n\n<span class=\"commenter-location\">00</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=9919727\" class=\"comment-time\" datetime=\"\">September 9, 2013</a>\n</header>\n<p class=\"comment-text\">\"Chastened by Hazing, University Band Returns\" (9/7/13). Shouldn't that be \"for hazing\"?</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"8547299\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=8547299\" data-parentid=\"0\" data-sequence=\"8547299\" data-permid=\"8547299\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">johntechwriter</h3>\n\n\n<span class=\"commenter-location\">Oakland Hills, CA</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=8547299\" class=\"comment-time\" datetime=\"\">March 18, 2013</a>\n</header>\n<p class=\"comment-text\">Wow! I've just come across this column and now understand why the NYT's style guide is not among those recommended for use in my trade, technical writing.<br><br>Rather than find it in your heart to forgive the singular \"they,\" you would shackle us scribblers of procedural docs forever with the awkward and faintly PC \"he or she.\"<br><br>You would have Bob Dylan entreat, \"Lie lady lie, lie upon my big brass bed.\"<br><br>Thos and some other disappointing calls in today's column leave me in even greater distress about the future of our beloved language. If we wordies can't agree, what gives us the moral authority to dictate to the texties?<br><br>Oh, and about the dropped apostrophe in place names: It's ancient history, old man. E. M. Forster's \"Howards End\" bestows the imprimatur of modern literature to said practice.</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"8467683\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=8467683\" data-parentid=\"0\" data-sequence=\"8467683\" data-permid=\"8467683\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Ben Krotoa</h3>\n\n\n<span class=\"commenter-location\">Oxford, UK</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=8467683\" class=\"comment-time\" datetime=\"\">March 8, 2013</a>\n</header>\n<p class=\"comment-text\">Please explain this to me: \"Get Off of Your Cloud\" (Maureen Dowd, Feb. 26). Why \"off of\"? Why not simply \"Get Off Your Cloud\"?</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n<div class=\"thread\"><article class=\"comment threaded-comment  \" data-id=\"8547034\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=8547034\" data-parentid=\"8467683\" data-sequence=\"8547034\" data-permid=\"8547034\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">johntechwriter</h3>\n\n\n<span class=\"commenter-location\">Oakland Hills, CA</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=8547034\" class=\"comment-time\" datetime=\"\">March 18, 2013</a>\n</header>\n<p class=\"comment-text\">As a Brit you should know the answer: to provide the syllable that fits the song's meter: \"Hey! You! Get off of my cloud!\"</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \"><span class=\"recommend-count\"><i class=\"icon sprite-icon\"></i>1</span>Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article></div>\n\n\n</article><article class=\"comment   \" data-id=\"8022147\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=8022147\" data-parentid=\"0\" data-sequence=\"8022147\" data-permid=\"8022147\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Lisa</h3>\n\n\n<span class=\"commenter-location\">Chicago, IL</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=8022147\" class=\"comment-time\" datetime=\"\">January 8, 2013</a>\n</header>\n<p class=\"comment-text\">Why does the New York Times repeatedly use the journalistic cliché \"tidy bungalow?\" I expect the Times to be better at avoiding such lazy writing.</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"6645027\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=6645027\" data-parentid=\"0\" data-sequence=\"6645027\" data-permid=\"6645027\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">john andrus</h3>\n\n\n<span class=\"commenter-location\">ocean city nj</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=6645027\" class=\"comment-time\" datetime=\"\">July 17, 2012</a>\n</header>\n<p class=\"comment-text\">The word “got” seems to be superfluous in oft-heard expressions like: We’ve got to do it.<br>\nI can only understand combining “have” and “got” if one is seeking emphasis.<br>\nAm I wrong?</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"6644073\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=6644073\" data-parentid=\"0\" data-sequence=\"6644073\" data-permid=\"6644073\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Patrick</h3>\n\n\n<span class=\"commenter-location\">Oregon</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=6644073\" class=\"comment-time\" datetime=\"\">July 17, 2012</a>\n</header>\n<p class=\"comment-text\">Here's a question: when did it become acceptable for people to say \"he graduated high school in...\" , in stead of, \"he graduated from high school in...\"?</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"6011461\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=6011461\" data-parentid=\"0\" data-sequence=\"6011461\" data-permid=\"6011461\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Connecticut Yankee</h3>\n\n\n<span class=\"commenter-location\">Stamford</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=6011461\" class=\"comment-time\" datetime=\"\">April 24, 2012</a>\n</header>\n<p class=\"comment-text\">Too often, speakers refer to a high school diploma as a degree. Wrong. A degree is only earned by those who satisfactorily complete college work.</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"5832712\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=5832712\" data-parentid=\"0\" data-sequence=\"5832712\" data-permid=\"5832712\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Janes153</h3>\n\n\n<span class=\"commenter-location\">San Francisco, CA</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=5832712\" class=\"comment-time\" datetime=\"\">April 3, 2012</a>\n</header>\n<p class=\"comment-text\">I suddenly seem to hear on every possible radio and tv show the misuse of LAY for LIE (eg Revenge a few weeks ago and this week's In Plain Sight, for two tv examples).  And on commercials?!!!   Always.  I've seen it in a few books as well, usually only one of many errors in a poorly copy-edited volume.</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \"><span class=\"recommend-count\"><i class=\"icon sprite-icon\"></i>1</span>Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"5740413\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=5740413\" data-parentid=\"0\" data-sequence=\"5740413\" data-permid=\"5740413\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Tlon</h3>\n\n\n<span class=\"commenter-location\">New York, NY</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=5740413\" class=\"comment-time\" datetime=\"\">March 14, 2012</a>\n</header>\n<p class=\"comment-text\">Regarding the NYTimes style, why do the writers always give the person's age?  Most of the time it is quite irrelevant.</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n<div class=\"thread\"><article class=\"comment threaded-comment  \" data-id=\"6597614\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=6597614\" data-parentid=\"5740413\" data-sequence=\"6597614\" data-permid=\"6597614\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Katherine</h3>\n\n\n<span class=\"commenter-location\">Suburban Philadelphia</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=6597614\" class=\"comment-time\" datetime=\"\">July 11, 2012</a>\n</header>\n<p class=\"comment-text\">It may not be relevant to the article itself, but is done to distinguish the subject from other people of the same name.  A person's place of residence is often given for the same purpose.</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article></div>\n\n\n</article><article class=\"comment   \" data-id=\"5738288\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=5738288\" data-parentid=\"0\" data-sequence=\"5738288\" data-permid=\"5738288\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Sonja Elson</h3>\n\n\n<span class=\"commenter-location\">California</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=5738288\" class=\"comment-time\" datetime=\"\">March 14, 2012</a>\n</header>\n<p class=\"comment-text\">Thank you for the clear explanations.  Your blogs vindicate my  'recommendations' to our online content providers.  </p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"5503328\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=5503328\" data-parentid=\"0\" data-sequence=\"5503328\" data-permid=\"5503328\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Reader</h3>\n\n\n<span class=\"commenter-location\">New York</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=5503328\" class=\"comment-time\" datetime=\"\">February 14, 2012</a>\n</header>\n<p class=\"comment-text\">\"“My feeling was it’s to early to do an extended tribute,” Mr. Ehrlich added, “but we really wanted to remember her because she was so closely tied to the Grammys.”\"<br><br><a href=\"http://www.nytimes.com/2012/02/12/arts/music/whitney-houston-dies.html?hp=&amp;pagewanted=all\" title=\"http://www.nytimes.com/2012/02/12/arts/music/whitney-houston-dies.html?hp=&amp;pagewanted=all\" target=\"_blank\">http://www.nytimes.com/2012/02/12/arts/music/whitney-houston-dies.html?h...</a><br><br>Would it be too too much to ask for some proofreading?</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \"><span class=\"recommend-count\"><i class=\"icon sprite-icon\"></i>1</span>Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"5462625\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=5462625\" data-parentid=\"0\" data-sequence=\"5462625\" data-permid=\"5462625\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Janes153</h3>\n\n\n<span class=\"commenter-location\">San Francisco, CA</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=5462625\" class=\"comment-time\" datetime=\"\">February 14, 2012</a>\n</header>\n<p class=\"comment-text\">From 2/7/2012's \"Court Strikes Down Ban on Gay Marriage in California\":  \"...that resulted in George W. Bush becoming president. \"  It should be \"Bush's becoming president.\" A gerund takes the possessive.</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"5230976\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=5230976\" data-parentid=\"0\" data-sequence=\"5230976\" data-permid=\"5230976\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">Ben Graham's Ghost</h3>\n\n\n<span class=\"commenter-location\">New Mexico</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=5230976\" class=\"comment-time\" datetime=\"\">January 10, 2012</a>\n</header>\n<p class=\"comment-text\">-- Please tell the world that the phrase \"That said... \" is a sign that the author wishes to be accepted by the popular but not erudite crowd.<br><br>-- A favorite from international attorney Catharine MacKinnon, quoting her c. late 1960s Smith College professor, Leo Weinstein:<br>\n\"'[R]eally' is the feminine expletive.\"</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><article class=\"comment   \" data-id=\"4840179\" data-url=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=4840179\" data-parentid=\"0\" data-sequence=\"4840179\" data-permid=\"4840179\" tabindex=\"30\">\n\n\n<header>\n<h3 class=\"commenter\">i.rodriguez</h3>\n\n\n<span class=\"commenter-location\">maryland</span>\n\n<a href=\"//afterdeadline.blogs.nytimes.com/2010/04/13/faqs-on-style/#permid=4840179\" class=\"comment-time\" datetime=\"\">December 27, 2011</a>\n</header>\n<p class=\"comment-text\">please comment on the current usage of the word \"issue\" which has devolved to be synonymous with \"problem\". an issue used to be a complex set of of problems such as the civil rights issue. it's use to describe a simple problem with a car or a home appliance appears to me to be a step backwards.</p>\n<footer>\n<ul class=\"comment-actions\">\n<li class=\"comment-flag login-modal-trigger \"><i class=\"icon sprite-icon\"></i>Flag</li>\n\n\n<li class=\"comment-recommend login-modal-trigger \">Recommend</li>\n<li class=\"sharetools\"><span class=\"facebook-share\" data-share=\"facebook\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Facebook</span></span><span class=\"twitter-share\" data-share=\"twitter\"><i class=\"icon sprite-icon\"></i><span class=\"visually-hidden\">Share this comment on Twitter</span></span></li>\n</ul>\n</footer>\n<div class=\"comment-form-control form-control reply-form-control active\"></div>\n\n</article><div class=\"loader-container\" style=\"display: none;\">\n<div class=\"loader loader-t-logo-32x32-ecedeb-ffffff\"><span class=\"visually-hidden\">Loading...</span></div>\n</div><footer class=\"comments-footer\">\n<div class=\"comments-expand comments-thread-expand\" data-action=\"read-more\" tabindex=\"55\" style=\"display: none;\">Read More <i class=\"icon\"></i></div>\n</footer></div><!-- close comments-view -->\n\n<div class=\"view-all\" data-filter=\"all\" style=\"display: none;\">View all 120 comments</div>\n\n</section><!-- close comments --><div class=\"comments-header-container\" style=\"display: none;\">\n<header class=\"comments-header\">\n<div id=\"Spon2\" class=\"ad comments-tile-ad\"></div>\n<h2 class=\"section-heading\" tabindex=\"1\"><i class=\"icon comments-icon\"></i>120 Comments</h2>\n\n\n<p class=\"comments-status\">The comments section is closed. To submit a letter to the editor for publication, write to <a href=\"mailto:letters@nytimes.com\">letters@nytimes.com</a>. </p>\n\n</header>\n\n<div class=\"comments-view-navigation\">\n<div class=\"tabs-container\">\n<ul class=\"tabs\">\n\n<li class=\"tab all selected\" data-filter=\"all\" tabindex=\"5\">All<span class=\"count\" data-filter=\"all\">&nbsp;120</span></li>\n\n</ul>\n</div>\n<div class=\"comments-sort-container\">\n<div class=\"comments-sort\" tabindex=\"5\">Newest</div><i class=\"icon\"></i>\n</div>\n</div>\n</div></div></div></div>\n            <div class=\"search-overlay\"></div>\n        <aside id=\"media-viewer\" class=\"media-viewer\" style=\"display:none;\">\n<button class=\"button close-button\"><i class=\"icon\"></i><span class=\"visually-hidden\">Close this overlay</span></button>\n<h2 class=\"media-viewer-headline\"></h2>\n<div class=\"media-viewer-wrapper\"></div>\n<nav class=\"media-viewer-nav\">\n<div class=\"media-viewer-counter\"></div>\n<div class=\"media-viewer-previous\">\n<span class=\"visually-hidden\">Go to previous</span>\n<div class=\"arrow arrow-left\">\n<div class=\"arrow-conceal\"></div>\n</div>\n</div>\n<div class=\"media-viewer-next\">\n<span class=\"visually-hidden\">Go to next</span>\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n</div></nav>\n<div class=\"loader-container\" style=\"display:none;\">\n<div class=\"loader loader-t-logo-32x32-ecedeb-ffffff\"><span class=\"visually-hidden\">Loading...</span></div>\n</div>\n</aside></main>\n        <!-- close main -->\n        <footer id=\"page-footer\" class=\"page-footer\" role=\"contentinfo\">\n            <nav>\n                <ul>\n                    <li>\n                        <a href=\"https://www.nytco.com\" itemprop=\"copyrightNotice\">\n                    © <span itemprop=\"copyrightYear\">2017</span>\n\t\t\t\t\t<span itemprop=\"copyrightHolder provider sourceOrganization\" itemscope=\"\" itemtype=\"//schema.org/Organization\" itemid=\"//www.nytimes.com\">\n\t\t\t\t\t\t<span itemprop=\"name\"> The New York Times Company</span>\n\t\t\t\t\t\t<meta itemprop=\"tickerSymbol\" content=\"NYSE NYT\">\n\t\t\t\t\t</span>\n                </a>\n                    </li>\n                    <li><a href=\"https://www.nytimes.com/ref/membercenter/help/infoservdirectory.html\">Contact Us</a></li>\n                    <li><a href=\"//www.nytco.com/careers/\">Work With Us</a></li>\n                    <li><a href=\"//nytmediakit.com/\">Advertise</a></li>\n                    <li><a href=\"https://www.nytimes.com/content/help/rights/privacy/policy/privacy-policy.html#pp\">Your Ad Choices</a></li>\n                    <li><a href=\"https://www.nytimes.com/privacy\">Privacy</a></li>\n                    <li><a href=\"https://www.nytimes.com/ref/membercenter/help/agree.html\" itemprop=\"usageTerms\">Terms of Service</a></li>\n                    <li class=\"last-item\"><a href=\"https://www.nytimes.com/content/help/rights/sale/terms-of-sale.html\">Terms of Sale</a></li>\n                </ul>\n            </nav>\n            <nav class=\"last-nav\">\n                <ul>\n                    <li><a href=\"//spiderbites.nytimes.com\">Site Map</a></li>\n                    <li><a href=\"https://www.nytimes.com/membercenter/sitehelp.html\">Help</a></li>\n                    <li><a href=\"https://myaccount.nytimes.com/membercenter/feedback.html\">Site Feedback</a></li>\n                    <li class=\"last-item\"><a href=\"https://www.nytimes.com/subscriptions/Multiproduct/lp5558.html?campaignId=37WXW\">Subscriptions</a></li>\n                </ul>\n            </nav>\n        </footer>\n    <nav data-href=\"\" data-queue-ad=\"false\" class=\"ribbon-page-navigation previous\" style=\"overflow: hidden;\">\n\n<a href=\"\">\n<article class=\"story theme-summary  no-thumb \" style=\"display: none; opacity: 1;\">\n\n<div class=\"summary\" style=\"margin-top: 32.7px;\">\n\n<h2 class=\"story-heading\"></h2>\n</div>\n</article>\n<div class=\"arrow arrow-left\">\n<span class=\"visually-hidden\">Go to the previous story</span>\n<div class=\"arrow-conceal\"></div>\n</div>\n</a>\n</nav><nav data-href=\"https://www.nytimes.com/2020/07/18/opinion/sunday/covid-schools-reopen-teacher-safety.html?rref=most-emailed\" data-queue-ad=\"\" class=\"ribbon-page-navigation ribbon-page-navigation-has-data next\" style=\"overflow:hidden;\">\n\n<a href=\"https://www.nytimes.com/2020/07/18/opinion/sunday/covid-schools-reopen-teacher-safety.html?rref=most-emailed\">\n<article class=\"story theme-summary \" style=\"display: none; opacity: 1;\">\n\n<div class=\"thumb\">\n<img src=\"https://static01.nyt.com/images/2020/07/18/opinion/18Martinson/18Martinson-thumbStandard.jpg\">\n</div>\n\n<div class=\"summary\" style=\"margin-top: 11.7px;\">\n\n<h2 class=\"story-heading\">Please Don’t Make Me Risk Getting Covid-19 to Teach Your Child</h2>\n</div>\n</article>\n<div class=\"arrow arrow-right\">\n<span class=\"visually-hidden\">Go to the next story</span>\n<div class=\"arrow-conceal\"></div>\n</div>\n</a>\n</nav></div>\n    <!-- close shell -->\n    <script>\n        require(['foundation/main'], function() {\n            require(['blogs/main']);\n            require(['https://static01.nyt.com/projects/blogs/js/tracking.js']);\n            // Blacklist some trackers imported from nyt5 legacy libraries\n            $(document).ajaxSend(function(event, jqXHR, settings) {\n                if (settings.url.indexOf && settings.url.indexOf('amazon-adsystem') !== -1) {\n                    jqXHR.abort();\n                }\n            });\n        });\n    </script>\n\n\n<iframe style=\"position: absolute; width: 1px; height: 1px; left: -9999px;\" src=\"//www.nytimes.com/svc/web/localstorage.html\"></iframe><div id=\"interstitial-ad-modal\" class=\"modal-container interstitial-ad-modal-container\" style=\"display: none;\"><div class=\"overlay\" style=\"display: block;\"></div>\n<div class=\"modal interstitial-ad-modal \" style=\"width: 640;\" role=\"dialog\" aria-labelledby=\"interstitial-ad-modal-modal-heading\" tabindex=\"-1\">\n<div class=\"modal-header\">\n<h3 class=\"modal-heading\" id=\"interstitial-ad-modal-modal-heading\">advertisement</h3>\n\n</div>\n<div class=\"modal-content\">\n<div id=\"Interstitial\" class=\"ad interstitial-ad\"></div><p class=\"user-action dismiss-button\">Continue »</p>\n</div>\n<div class=\"modal-footer\">\n\n</div>\n<button type=\"button\" class=\"modal-close \" aria-disabled=\"false\"><i class=\"icon\"></i><span class=\"visually-hidden\">Close this modal window</span></button>\n<div class=\"modal-pointer modal-pointer-fixed\"><div class=\"modal-pointer-conceal\"></div></div>\n</div></div><div id=\"login-modal\" class=\"modal-container login-modal-container\" style=\"display: none;\"><div class=\"overlay\" style=\"display: block;\"></div>\n<div class=\"modal login-modal account-modal\" style=\"width: undefined;\" role=\"dialog\" aria-labelledby=\"login-modal-modal-heading\" tabindex=\"-1\">\n<div class=\"modal-header\">\n<h3 class=\"modal-heading\" id=\"login-modal-modal-heading\">Log in</h3>\n<h4 class=\"modal-subheading\">To save articles or get newsletters, alerts or recommendations – all free.</h4>\n</div>\n<div class=\"modal-content\">\n<div class=\"buttons\">\n<button id=\"facebook-oauth-button-login-modal\" data-provider-name=\"facebook\" class=\"button oauth-button facebook-oauth-button\">\n<i class=\"icon sprite-icon\"></i>\n<span class=\"button-text\">Log in with Facebook</span>\n</button>\n<button id=\"google-oauth-button-login-modal\" data-provider-name=\"google\" class=\"button oauth-button google-oauth-button\">\n<i class=\"icon sprite-icon\"></i>\n<span class=\"button-text\">Log in with Google</span>\n</button>\n</div><!-- close buttons -->\n<div class=\"separator\">\n<span class=\"separator-text\">OR</span>\n</div>\n<div class=\"login-form-control form-control\">\n<form id=\"login-form\" class=\"login-form\" role=\"form\" method=\"post\" action=\"https://myaccount.nytimes.com/auth/login?URI=https%3A%2F%2Fafterdeadline.blogs.nytimes.com%2F2010%2F04%2F13%2Ffaqs-on-style%2F\">\n<div class=\"control\">\n<div class=\"label-container visually-hidden\">\n<label for=\"login-email\" id=\"login-email-label\">Email address</label>\n</div>\n<div class=\"field-container\">\n<input type=\"text\" id=\"login-email\" name=\"userid\" class=\"text login-email\" placeholder=\"Email address\" aria-labelledby=\"login-email-label\" aria-required=\"true\">\n<button type=\"button\" class=\"button clear-button\" tabindex=\"-1\" aria-describedby=\"clear-email-description\"><i class=\"icon\"></i><span class=\"visually-hidden\" id=\"clear-email-description\">Clear this text input</span></button>\n</div>\n</div>\n<div class=\"control\">\n<div class=\"label-container visually-hidden\">\n<label for=\"login-password\" id=\"login-password-label\">Password</label>\n</div>\n<div class=\"field-container\">\n<input type=\"password\" id=\"login-password\" name=\"password\" class=\"text login-password\" placeholder=\"Password\" data-type=\"password\" aria-labelledby=\"login-password-label\" aria-required=\"true\">\n<button type=\"button\" class=\"button clear-button\" tabindex=\"-1\" aria-describedby=\"clear-password-description\"><i class=\"icon\"></i><span class=\"visually-hidden\" id=\"clear-password-description\">Clear this text input</span></button>\n</div>\n</div>\n<div class=\"control user-action-control layout-horizontal\">\n<div class=\"control checkbox-control\">\n<div class=\"field-container\">\n<input type=\"checkbox\" id=\"login-remember-checkbox\" name=\"login-remember\" class=\"checkbox login-remember\" checked=\"checked\" aria-labelledby=\"login-remember-label\" aria-checked=\"true\" value=\"\">\n</div>\n<div class=\"label-container\">\n<label for=\"login-remember\" class=\"checkbox-label\" id=\"login-remember-label\">Remember me</label>\n</div>\n</div>\n<p class=\"form-hint password-hint\"><a href=\"https://myaccount.nytimes.com/seg/forgot-password?EXIT_URI=https%3A%2F%2Fafterdeadline.blogs.nytimes.com%2F2010%2F04%2F13%2Ffaqs-on-style%2F\">Forgot password?</a></p>\n</div>\n<div class=\"control\">\n<p class=\"disclaimer\"><a href=\"http://www.nytimes.com/content/help/rights/terms/terms-of-service.html\">Terms of Service</a> <a href=\"http://www.nytimes.com/content/help/rights/privacy/policy/privacy-policy.html\">Privacy Policy</a></p>\n</div>\n<div class=\"control button-control\">\n<button id=\"login-send-button\" class=\"button login-button\">Log in</button>\n</div>\n<input name=\"is_continue\" value=\"1\" type=\"hidden\">\n<input id=\"account-form-token\" name=\"token\" value=\"\" type=\"hidden\">\n<input id=\"account-form-expiration\" name=\"expires\" value=\"\" type=\"hidden\">\n<input id=\"login-remember\" name=\"remember\" value=\"1\" type=\"hidden\">\n</form>\n</div><!-- close login-form-control -->\n</div>\n<div class=\"modal-footer\">\n<p class=\"user-action registration-modal-trigger\">Don’t have an account? <a href=\"javascript:;\">Sign Up</a></p>\n</div>\n<button type=\"button\" class=\"modal-close \" aria-disabled=\"false\"><i class=\"icon\"></i><span class=\"visually-hidden\">Close this modal window</span></button>\n<div class=\"modal-pointer modal-pointer-fixed\"><div class=\"modal-pointer-conceal\"></div></div>\n</div></div><div id=\"registration-modal\" class=\"modal-container registration-modal-container\" style=\"display: none;\"><div class=\"overlay\" style=\"display: block;\"></div>\n<div class=\"modal registration-modal account-modal\" style=\"width: undefined;\" role=\"dialog\" aria-labelledby=\"registration-modal-modal-heading\" tabindex=\"-1\">\n<div class=\"modal-header\">\n<h3 class=\"modal-heading\" id=\"registration-modal-modal-heading\">Sign up</h3>\n<h4 class=\"modal-subheading\">To save articles or get newsletters, alerts or recommendations – all free.</h4>\n</div>\n<div class=\"modal-content\">\n<div class=\"buttons\">\n<button id=\"facebook-oauth-button-registration-modal\" data-provider-name=\"facebook\" class=\"button oauth-button facebook-oauth-button\">\n<i class=\"icon sprite-icon\"></i>\n<span class=\"button-text\">Sign up with Facebook</span>\n</button>\n<button id=\"google-oauth-button-registration-modal\" data-provider-name=\"google\" class=\"button oauth-button google-oauth-button\">\n<i class=\"icon sprite-icon\"></i>\n<span class=\"button-text\">Sign up with Google</span>\n</button>\n</div><!-- close buttons -->\n<div class=\"separator\">\n<span class=\"separator-text\">OR</span>\n</div>\n<div class=\"registration-form-control form-control\">\n<form id=\"registration-form\" class=\"registration-form\" role=\"form\" method=\"post\" action=\"https://myaccount.nytimes.com/register?URI=https%3A%2F%2Fafterdeadline.blogs.nytimes.com%2F2010%2F04%2F13%2Ffaqs-on-style%2F\">\n<div class=\"control\">\n<div class=\"label-container visually-hidden\">\n<label for=\"register-email\" id=\"register-email-label\">Email address</label>\n</div>\n<div class=\"field-container\">\n<input type=\"email\" id=\"register-email\" name=\"email_address\" class=\"text register-email\" placeholder=\"Email address\" aria-labelledby=\"register-email-label\" aria-required=\"true\">\n<button type=\"button\" class=\"button clear-button\" tabindex=\"-1\" aria-describedby=\"clear-email-description\"><i class=\"icon\"></i><span class=\"visually-hidden\" id=\"clear-email-description\">Clear this text input</span></button>\n</div>\n</div><!-- close control -->\n<div class=\"control\">\n<div class=\"label-container visually-hidden\">\n<label for=\"register-password\" id=\"register-password-label\">Password</label>\n</div>\n<div class=\"field-container\">\n<input type=\"password\" id=\"register-password\" name=\"password1\" class=\"text register-password\" placeholder=\"Password\" data-type=\"password\" aria-labelledby=\"register-password-label\" aria-required=\"true\">\n<button type=\"button\" class=\"button clear-button\" tabindex=\"-1\" aria-describedby=\"clear-password-description\"><i class=\"icon\"></i><span class=\"visually-hidden\" id=\"clear-password-description\">Clear this text input</span></button>\n</div>\n</div><!-- close control -->\n<div class=\"control\">\n<div class=\"label-container visually-hidden\">\n<label for=\"retype-password\" id=\"retype-password-label\">Retype password</label>\n</div>\n<div class=\"field-container\">\n<input type=\"password\" id=\"retype-password\" name=\"password2\" class=\"text retype-password\" placeholder=\"Retype password\" data-type=\"password\" aria-labelledby=\"retype-password-label\" aria-required=\"true\">\n<button type=\"button\" class=\"button clear-button\" tabindex=\"-1\" aria-describedby=\"clear-retyped-password-description\"><i class=\"icon\"></i><span class=\"visually-hidden\" id=\"clear-retyped-password-description\">Clear this text input</span></button>\n</div>\n</div><!-- close control -->\n<div class=\"control layout-horizontal special-offers\">\n<input class=\"checkbox special-offers-checkbox\" id=\"special-offers-checkbox\" type=\"checkbox\" name=\"mnl_opt_in_proxy\" value=\"\" checked=\"checked\">\n<label class=\"form-hint special-offers-label\" for=\"special-offers-checkbox\">\nYou agree to receive occasional updates and special offers for The New York Times's products and services. You may opt out or <a href=\"/help/index.html\">contact us</a> anytime.\n</label>\n<input class=\"special-offers-hidden\" type=\"hidden\" name=\"mnl_opt_in\" value=\"\">\n</div>\n<div class=\"control\">\n<p class=\"disclaimer\"><a href=\"http://www.nytimes.com/content/help/rights/terms/terms-of-service.html\">Terms of Service</a> <a href=\"http://www.nytimes.com/content/help/rights/privacy/policy/privacy-policy.html\">Privacy Policy</a> <a href=\"/help/index.html\">Contact Us</a></p>\n</div>\n<div class=\"control button-control\">\n<button id=\"register-send-button\" class=\"button register-button\">Create Account</button>\n</div>\n<input name=\"is_continue\" value=\"1\" type=\"hidden\">\n<input id=\"account-form-token\" name=\"token\" value=\"\" type=\"hidden\">\n<input id=\"account-form-expiration\" name=\"expires\" value=\"\" type=\"hidden\">\n<input name=\"signupFormVersions\" class=\"signupFormVersions\" value=\"NYT5_MyAccount_Modal_global_v2\" type=\"hidden\">\n</form>\n</div><!-- close registration-form-control -->\n</div>\n<div class=\"modal-footer\">\n<p class=\"user-action login-modal-trigger\">Already have an account? <a href=\"javascript:;\">Log In</a></p>\n</div>\n<button type=\"button\" class=\"modal-close \" aria-disabled=\"false\"><i class=\"icon\"></i><span class=\"visually-hidden\">Close this modal window</span></button>\n<div class=\"modal-pointer modal-pointer-fixed\"><div class=\"modal-pointer-conceal\"></div></div>\n</div></div><div id=\"user-name-modal\" class=\"modal-container user-name-modal-container\" style=\"display: none;\"><div class=\"overlay\" style=\"display: none;\"></div>\n<div class=\"modal user-name-modal \" style=\"width: 260px;\" role=\"dialog\" aria-labelledby=\"user-name-modal-modal-heading\" tabindex=\"-1\">\n<div class=\"modal-header\">\n<h3 class=\"modal-heading\" id=\"user-name-modal-modal-heading\">\n<span class=\"user-name-subscription\">\n<span class=\"user-name\"></span>\n\n</span></h3>\n\n</div>\n<div class=\"modal-content\">\n<ul>\n<li><a href=\"javascript:;\" class=\"user-profile-button\">Edit Profile</a></li>\n<li><a href=\"https://myaccount.nytimes.com/membercenter/myaccount.html\">My Account</a></li>\n<li><a href=\"https://myaccount.nytimes.com/get-started/manage-billing?EXIT_URI=https%3A%2F%2Fafterdeadline.blogs.nytimes.com%2F2010%2F04%2F13%2Ffaqs-on-style%2F\">My Billing Information</a></li>\n<li><a href=\"http://www.nytimes.com/saved\">My Saved Items</a></li>\n<li><button class=\"button log-out-button\">Log Out</button></li>\n</ul>\n</div>\n<div class=\"modal-footer\">\n\n</div>\n<button type=\"button\" class=\"modal-close hidden\" aria-disabled=\"false\"><i class=\"icon\"></i><span class=\"visually-hidden\">Close this modal window</span></button>\n<div class=\"modal-pointer modal-pointer-up-right\"><div class=\"modal-pointer-conceal\"></div></div>\n</div></div><div id=\"user-settings-modal\" class=\"modal-container user-settings-modal-container\" style=\"display: none;\"><div class=\"overlay\" style=\"display: none;\"></div>\n<div class=\"modal user-settings-modal \" style=\"width: 260px;\" role=\"dialog\" aria-labelledby=\"user-settings-modal-modal-heading\" tabindex=\"-1\">\n<div class=\"modal-header\">\n<h3 class=\"modal-heading\" id=\"user-settings-modal-modal-heading\"></h3>\n\n</div>\n<div class=\"modal-content\">\n<div class=\"menu edition-menu\">\n<h5 class=\"modal-heading\">Edition</h5>\n<ul>\n\n<li><a href=\"https://www.nytimes.com\" data-edition=\"us\" class=\"selected\">English</a></li>\n\n<li><a href=\"http://cn.nytimes.com\" data-edition=\"chinese\">中文 (Chinese)</a></li>\n<li><a href=\"https://www.nytimes.com/es/\" data-edition=\"spanish\">Español</a></li>\n</ul>\n</div>\n<div class=\"menu help-menu\">\n<h5 class=\"modal-heading\">Help</h5>\n<ul>\n<li><a href=\"https://www.nytimes.com/content/help/front.html\">FAQ</a></li>\n<li><a href=\"http://www.nytimes.com/help/index.html\">Contact Us</a></li>\n</ul>\n</div>\n\n<div class=\"menu type-sizer-menu\">\n<h5 class=\"modal-heading\">Type Size</h5>\n<ul>\n<li data-size=\"small\" class=\"type-sizer-small type-size-selected\"><a href=\"javascript:;\">A <span class=\"visually-hidden\">Type size small</span></a></li>\n<li data-size=\"medium\" class=\"type-sizer-medium\"><a href=\"javascript:;\">A <span class=\"visually-hidden\">Type size medium</span></a></li>\n<li data-size=\"large\" class=\"type-sizer-large\"><a href=\"javascript:;\">A <span class=\"visually-hidden\">Type size large</span></a></li>\n</ul>\n</div>\n\n</div>\n<div class=\"modal-footer\">\n\n</div>\n<button type=\"button\" class=\"modal-close hidden\" aria-disabled=\"false\"><i class=\"icon\"></i><span class=\"visually-hidden\">Close this modal window</span></button>\n<div class=\"modal-pointer modal-pointer-up-right\"><div class=\"modal-pointer-conceal\"></div></div>\n</div></div><div id=\"navigation-modal\" class=\"modal-container navigation-modal-container\" style=\"display: none;\"><div class=\"overlay\" style=\"display: none;\"></div>\n<div class=\"modal navigation-modal \" style=\"width: undefined;\" role=\"dialog\" aria-labelledby=\"navigation-modal-modal-heading\" tabindex=\"-1\">\n<div class=\"modal-header\">\n<h3 class=\"modal-heading\" id=\"navigation-modal-modal-heading\"></h3>\n\n</div>\n<div class=\"modal-content\">\n<div class=\"secondary-container\">\n<div class=\"secondary-container\">\n<div class=\"header\">\n<h5 class=\"section-heading\"><a href=\"\" role=\"menuitem\"></a></h5>\n</div>\n\n<div class=\"section \" data-parent=\"navId-9A43D8FC-F4CF-44D9-9B34-138D30468F8F\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-350E94CC-926C-4D2A-9DB4-FD9ED99A66DC\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/world/africa\">\nAfrica\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-5A94A97E-037B-4C6B-A88D-741B06663078\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/world/americas\">\nAmericas\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-881A1D77-D6D7-4AC3-AAC2-4C279C20DD66\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/world/asia\">\nAsia Pacific\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-A0EAB3C7-588D-4930-AC9B-57E2A8F8AD32\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/world/australia\">\nAustralia\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-D38BAA6D-F26D-4B3E-BF25-CC798E6C5F55\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/world/europe\">\nEurope\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-108390AA-728E-41EB-B9B5-14EDFBAE7D20\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/world/middleeast\">\nMiddle East\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary 9A43D8FC-F4CF-44D9-9B34-138D30468F8F sections -->\n\n<div class=\"section \" data-parent=\"navId-23FD6C8B-62D5-4CEA-A331-6C2A9A1223BE\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-C7303E0D-6EB2-4FD3-B968-530EF9F38EB1\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/education\">\nEducation\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-D64FAE4C-4425-4E5A-B898-6C8CB59F9957\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/upshot\">\nThe Upshot\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary 23FD6C8B-62D5-4CEA-A331-6C2A9A1223BE sections -->\n\n<div class=\"section \" data-parent=\"navId-80E6DEE6-87E4-4AD0-9152-14FA6B07E5AB\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-78CE290F-672B-4BC7-BD4E-67DA85BCAC4E\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/news-event/2020-election\">\nElection 2020\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-D64FAE4C-4425-4E5A-B898-6C8CB59F9957\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/upshot\">\nThe Upshot\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary 80E6DEE6-87E4-4AD0-9152-14FA6B07E5AB sections -->\n\n<div class=\"section \" data-parent=\"navId-C4DC8C0C-E148-4201-BF10-82F1C903DBFB\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-2D1C1EB8-E0D9-40A9-8D59-3908DCF5C9BD\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/spotlight/arts-listings\">\nEvents\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary C4DC8C0C-E148-4201-BF10-82F1C903DBFB sections -->\n\n<div class=\"section \" data-parent=\"navId-104D1E63-9701-497B-8CF4-A4D120C9014E\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-71301FE1-FE94-4AF4-978B-39B2D2C59D31\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/business/dealbook\">\nDealBook\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-2848A7AC-A33D-4352-B1FC-A465B81CD4F1\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/business/economy\">\nEconomy\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-E1B05D9E-B6F8-46DB-89E5-06F2205C8085\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/business/energy-environment\">\nEnergy\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-4A7070FF-9307-4094-AE79-910158959A60\" class=\" \" role=\"menuitem\" href=\"https://markets.on.nytimes.com/research/markets/overview/overview.asp\">\nMarkets\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-C691FB48-A7E8-44FB-9AAA-13D91863D336\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/business/media\">\nMedia\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-AD2AE740-D1A5-4EDB-970D-F56370072B09\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/business/smallbusiness\">\nEntrepreneurship\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-ED7B8594-44CE-4D37-A58B-1CDAA19774E4\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/your-money\">\nYour Money\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-0A13AF9D-C7B5-4E8A-B9BC-15AB4B572C94\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/automobiles\">\nAutomobiles\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary 104D1E63-9701-497B-8CF4-A4D120C9014E sections -->\n\n<div class=\"section \" data-parent=\"navId-AD8090D7-4137-4D71-84C8-70DA3BD89778\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-9568A8E4-DD00-4A19-9357-55F8E84ADDB5\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/opinion/columnists\" aria-haspopup=\"true\" aria-expanded=\"false\">\nOp-Ed Columnists\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n<div class=\"arrow arrow-left\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-6E604B7F-ACE7-4564-9203-0BD4CB02F419\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/opinion/editorials\">\nEditorials\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-B3CE1F6E-B530-4C07-9B1C-98A1F9406C06\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/opinion/contributors\">\nOp-Ed Contributors\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-7A239778-088E-4DD8-BEBF-649172041293\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/opinion/letters\">\nLetters\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-67D7F2A2-B495-4FFC-9478-1CE1965601D5\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/opinion/sunday\">\nSunday Review\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary AD8090D7-4137-4D71-84C8-70DA3BD89778 sections -->\n\n<div class=\"section \" data-parent=\"navId-78FBAD45-31A9-4EC7-B172-7D62A2B9955E\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-65229E4E-DAD7-459F-AFD3-2AB6D0374FFD\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/technology/personaltech\">\nPersonal Tech\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary 78FBAD45-31A9-4EC7-B172-7D62A2B9955E sections -->\n\n<div class=\"section \" data-parent=\"navId-A4B35924-DB6C-4EA3-997D-450810F4FEE6\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-B831ACFB-B751-4F23-9B91-F1236878836C\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/climate\">\nClimate\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-E048A75C-4A9C-4241-B38C-74752BBC5AB8\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/science/space\">\nSpace &amp; Cosmos\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary A4B35924-DB6C-4EA3-997D-450810F4FEE6 sections -->\n\n<div class=\"section \" data-parent=\"navId-7D6BE1AF-8CD8-430B-8B2A-17CD0EAA99AC\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-5A98BF31-516F-48DE-8736-17BEEF1F64C6\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/well\">\nWell\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-67641EB3-B6FF-44F2-B10F-2F6A5C2EC7D7\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/health/policy\">\nMoney &amp; Policy\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-DA27E208-2682-4B17-8996-CD35A339521B\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/health/guides/index.html\">\nHealth Guide\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary 7D6BE1AF-8CD8-430B-8B2A-17CD0EAA99AC sections -->\n\n<div class=\"section \" data-parent=\"navId-DE2B278B-2783-4506-AAD5-C15A5BB6DA1A\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-67CAE5A6-408D-44F3-827B-DD394E0467EF\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/sports/baseball\">\nBaseball\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-BA1B9016-F2F7-454B-BDF7-D4C58F6D05E9\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/sports/ncaabasketball\">\nBasketball: College\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-415FB1AB-3BED-4048-B61A-0E4096CE1DF6\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/sports/basketball\">\nBasketball: N.B.A.\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-ABBA0609-90E2-46A3-9AC5-B208ACC6C97B\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/sports/ncaafootball\">\nFootball: College\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-F6B9D6C9-97AE-45DB-9686-72E44D8D3DAF\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/sports/football\">\nFootball: N.F.L.\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-9F98FEDB-E7B3-4907-A56E-35320CC4C878\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/sports/golf\">\nGolf\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-BD14DADE-D513-4BD9-8AED-0CC63E58606C\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/sports/hockey\">\nHockey\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-14F230C0-EBDB-4A78-AF7B-2C90C4739625\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/sports/soccer\">\nSoccer\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-D4DE47DA-76DD-4528-B539-98A6DFEFEFB3\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/sports/tennis\">\nTennis\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary DE2B278B-2783-4506-AAD5-C15A5BB6DA1A sections -->\n\n<div class=\"section \" data-parent=\"navId-C5BFA7D5-359C-427B-90E6-6B7245A6CDD8\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-AB35105B-5032-41D9-86B1-06A221411B22\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/arts/design\">\nArt &amp; Design\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-21A8F511-CA05-4797-AF76-17B61D3964CD\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/arts/dance\">\nDance\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-62BF6D00-C2D2-420E-9986-791EECA152C9\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/movies\">\nMovies\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-E0A8CBEB-DDB5-4ADF-B5A4-60CB484ED991\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/arts/music\">\nMusic\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-1B3D562C-A3F9-4083-9B6E-60C8A1F3FFB0\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/spotlight/arts-listings\">\nN.Y.C. Events Guide\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-EF6D2985-BB93-4771-8155-CC3E2B5A7C73\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/arts/television\">\nTelevision\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-21D5B838-29CC-46D3-9006-879CAABC8F08\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/theater\">\nTheater\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-2558194D-A450-4F5B-8E90-8609A69E1D0E\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/watching\">\nWatching\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary C5BFA7D5-359C-427B-90E6-6B7245A6CDD8 sections -->\n\n<div class=\"section \" data-parent=\"navId-7B052F64-13C5-4631-ACE4-F1BAA9706061\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-C3EA2DF4-3843-4896-9EF0-EB7CEF2310F9\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/books/best-sellers/\">\nBest Sellers\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-B534AF80-3CBB-43E4-8ACE-3ADF43783A5A\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/by-the-book\">\nBy the Book\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-BBBC6AB4-3383-4435-98FA-3B7D3B34B571\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/books/review\">\nThe Book Review\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-4098F2BC-D74A-4EB3-8156-9753D40E6658\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/book-review-podcast\">\nBook Review Podcast\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-7DF50B73-3F77-A8D1-F66A-2964450790A9\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/interactive/2019/01/19/books/new-books-international.html\">\nGlobetrotting\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary 7B052F64-13C5-4631-ACE4-F1BAA9706061 sections -->\n\n<div class=\"section \" data-parent=\"navId-B3DFBD82-F298-43B3-9458-219B4F6AA2A5\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-7A870CC7-2938-4C8E-B8F2-BD54465ECB58\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/fashion/mens-style\">\nMen's Style\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-38E82E5A-D1EE-4A54-BC61-9155577ABAED\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/on-the-runway\">\nOn the Runway\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-D0F14EC9-05BC-4188-AE41-A4CD18FD19AD\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/fashion/weddings\">\nWeddings\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary B3DFBD82-F298-43B3-9458-219B4F6AA2A5 sections -->\n\n<div class=\"section \" data-parent=\"navId-D9C94A2B-0364-4D25-8383-592CC66F82D4\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-EC43C53C-07AC-42DF-8EA3-34F4EFCD6524\" class=\" \" role=\"menuitem\" href=\"https://cooking.nytimes.com\">\nCooking\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-63AB32FE-1AA9-4C10-85CF-86088BC725B7\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/reviews/dining\">\nRestaurant Search\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary D9C94A2B-0364-4D25-8383-592CC66F82D4 sections -->\n\n<div class=\"section \" data-parent=\"navId-92720057-BCB6-4BDB-9351-12F29393259F\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-D896FA09-BB54-4280-BAC5-268E5CAC9D84\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/real-estate/the-high-end\">\nThe High End\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-00B951BD-2AE1-4E28-BAF7-18D1FAA6AA97\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/realestate/commercial\">\nCommercial\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-9AE506A2-9337-4A5E-8499-E3781316FF13\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/real-estate/find-a-home\">\nFind A Home\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-FD7A7999-4B42-4E71-9876-DF55D957FD1B\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/real-estate/mortgage-calculator\">\nMortgage Calculator\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-E4FBD546-F591-4961-9A7B-1348506F24ED\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/real-estate/my-real-estate\">\nMy Real Estate\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-58BA565B-0B7B-4DCF-9051-A8F77BF82FC5\" class=\" \" role=\"menuitem\" href=\"https://realestateads.nytimes.com/\">\nList Your Home\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary 92720057-BCB6-4BDB-9351-12F29393259F sections -->\n\n<div class=\"section video\" data-parent=\"navId-432A1823-3F24-43C0-8004-79088F94E754\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-FAF08756-1545-4233-B9D6-FEFA1115CFA6\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/us-politics\">\nU.S. &amp; Politics\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-63D27866-95B7-47BC-9B53-E250CA21E182\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/world\">\nInternational\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-281517E5-9CC5-472C-B46A-B9CF9AAE72F2\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/n-y-region\">\nN.Y.\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-C5D5043A-85D5-4E97-BE08-8D0278F97101\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/op-docs\">\nOp-Docs\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-6AB2572C-5341-4979-8D74-E38528FE0159\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/opinion\">\nOpinion\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-50BEEE33-737A-4EBE-98D7-65593C23AE6C\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/times-documentaries\">\nTimes Documentaries\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-18CC8E0D-C9B6-4A81-8EB6-9AC98B296DDB\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/business\">\nBusiness\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-457A829A-6C9D-47A9-B91E-2212766B6648\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/technology\">\nTech\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-4CF1B9A6-4476-45CF-AF12-53B7EB39847F\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/arts\">\nCulture\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-3BAEEBB7-10C5-43F9-A728-26DCE4D44B48\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/style\">\nStyle\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-1CB4FCE4-8D2A-4313-9EBC-32F88BD90A35\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/t-magazine\">\nT Magazine\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-6872F49C-F4A1-458D-8410-B253D44B8E9C\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/health\">\nHealth\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-A3E833FD-09AE-4B1B-B4A7-AED0CF1CC74C\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/dining-and-wine\">\nFood\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-380D52A1-A468-4069-BCA9-52D6E2625D63\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/travel\">\nTravel\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-DAB634A7-D513-49CA-BBEF-9FB321BF6798\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/sports\">\nSports\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-64C01CC7-C6F7-4E1B-A4FD-69B6D5B647FE\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/real-estate\">\nReal Estate\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-6F4D6D03-8D74-4A7C-939D-2ADEE18731CB\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/video/science\">\nScience\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary 432A1823-3F24-43C0-8004-79088F94E754 sections -->\n\n<div class=\"section \" data-parent=\"navId-0442C365-4B63-4B63-B9DE-3C28319CB622\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-0273790F-9086-41CE-82F1-B83A0FAEED21\" class=\" \" role=\"menuitem\" href=\"http://nytdealbookconference.com/\">\nDealBook\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-AF65E7CA-4FFC-4D88-B058-0078442F8EE1\" class=\" \" role=\"menuitem\" href=\"http://nytclimatetech.com\">\nClimateTECH\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-D6413F29-94B5-4296-9BEC-8DC523575CA7\" class=\" \" role=\"menuitem\" href=\"http://nytglobalstrategy.com\">\nGlobal Strategy Summit\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-53D738B7-9EAE-4650-8E5C-28B3F19B4C88\" class=\" \" role=\"menuitem\" href=\"http://nytluxury.com\">\nInternational Luxury Conference\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-81785E85-A8E4-43E5-B6EA-C623C887B9BB\" class=\" \" role=\"menuitem\" href=\"http://nytluxurytravel.com\">\nLuxury Travel\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-61F54F21-A0A9-46B9-BDC5-22BDDAD4007A\" class=\" \" role=\"menuitem\" href=\"http://newworksummit.com\">\nNew Work Summit\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-CB602764-3E17-4A16-BBD4-08138CFDBD81\" class=\" \" role=\"menuitem\" href=\"http://nythigheredleaders.com\">\nHigher Ed Leaders Forum\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-DF70A828-4A23-4295-9560-8D8B5FC097B0\" class=\" \" role=\"menuitem\" href=\"http://athensdemocracyforum.com\">\nAthens Democracy Forum\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-10C4EAE9-339E-456F-A1F0-7C870299C310\" class=\" \" role=\"menuitem\" href=\"http://oilandmoney.com\">\nOil &amp; Money\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-ACB65949-CC1A-42DC-8415-041271C130AD\" class=\" \" role=\"menuitem\" href=\"http://nytartleadersnetwork.com\">\nArt Leaders Network\n\n</a>\n</li>\n\n</ul>\n</div><!-- close secondary 0442C365-4B63-4B63-B9DE-3C28319CB622 sections -->\n\n<div class=\"section section-more hidden\" data-parent=\"navId-more-section\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-A963B567-7D3D-4D0C-9E47-BF91609EFCE7\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com\">\nHome Page\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-9A43D8FC-F4CF-44D9-9B34-138D30468F8F\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/world\" aria-haspopup=\"true\" aria-expanded=\"false\">\nWorld\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-23FD6C8B-62D5-4CEA-A331-6C2A9A1223BE\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/us\" aria-haspopup=\"true\" aria-expanded=\"false\">\nU.S.\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-80E6DEE6-87E4-4AD0-9152-14FA6B07E5AB\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/politics\" aria-haspopup=\"true\" aria-expanded=\"false\">\nPolitics\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-C4DC8C0C-E148-4201-BF10-82F1C903DBFB\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/nyregion\" aria-haspopup=\"true\" aria-expanded=\"false\">\nN.Y.\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-104D1E63-9701-497B-8CF4-A4D120C9014E\" class=\"domestic expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/business\" aria-haspopup=\"true\" aria-expanded=\"false\">\nBusiness\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-A257D89A-0D3C-40AF-9C34-1A25A7947D94\" class=\"international \" role=\"menuitem\" href=\"https://www.nytimes.com/section/business\">\nBusiness\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-AD8090D7-4137-4D71-84C8-70DA3BD89778\" class=\"domestic expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/opinion\" aria-haspopup=\"true\" aria-expanded=\"false\">\nOpinion\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-09736473-CB3F-4B2F-9772-3AF128ABE12D\" class=\"international \" role=\"menuitem\" href=\"https://www.nytimes.com/section/opinion\">\nOpinion\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-78FBAD45-31A9-4EC7-B172-7D62A2B9955E\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/technology\" aria-haspopup=\"true\" aria-expanded=\"false\">\nTech\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-A4B35924-DB6C-4EA3-997D-450810F4FEE6\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/science\" aria-haspopup=\"true\" aria-expanded=\"false\">\nScience\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-7D6BE1AF-8CD8-430B-8B2A-17CD0EAA99AC\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/health\" aria-haspopup=\"true\" aria-expanded=\"false\">\nHealth\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-DE2B278B-2783-4506-AAD5-C15A5BB6DA1A\" class=\"domestic expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/sports\" aria-haspopup=\"true\" aria-expanded=\"false\">\nSports\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-BE66F420-C51B-461D-B487-CACF62E94AAE\" class=\"international \" role=\"menuitem\" href=\"https://www.nytimes.com/section/sports\">\nSports\n\n</a>\n</li>\n\n\n\n</ul>\n</div>\n\n<div class=\"section section-more\" data-parent=\"navId-more-section\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-C5BFA7D5-359C-427B-90E6-6B7245A6CDD8\" class=\"domestic expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/arts\" aria-haspopup=\"true\" aria-expanded=\"false\">\nArts\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-0202D0E4-C59B-479A-BD42-6F1766459781\" class=\"international \" role=\"menuitem\" href=\"https://www.nytimes.com/section/arts\">\nArts\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-7B052F64-13C5-4631-ACE4-F1BAA9706061\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/books\" aria-haspopup=\"true\" aria-expanded=\"false\">\nBooks\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-B3DFBD82-F298-43B3-9458-219B4F6AA2A5\" class=\"domestic expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/style\" aria-haspopup=\"true\" aria-expanded=\"false\">\nStyle\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-CC9E2674-F6C4-4A39-813B-F5AB0C515CEA\" class=\"international \" role=\"menuitem\" href=\"https://www.nytimes.com/section/style\">\nStyle\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-D9C94A2B-0364-4D25-8383-592CC66F82D4\" class=\"domestic expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/food\" aria-haspopup=\"true\" aria-expanded=\"false\">\nFood\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-FDEFB811-B483-4C3D-A25A-FD07BE5EAD96\" class=\"international \" role=\"menuitem\" href=\"https://www.nytimes.com/section/food\">\nFood\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-FDA10AC4-4738-4099-91E8-15584765C8D7\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/travel\">\nTravel\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-E57A148E-0CB9-4C02-966D-28B119710151\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/magazine\">\nMagazine\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-052C33AD-1404-4DB6-AA70-0901DB1AD95B\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/t-magazine\">\nT Magazine\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-92720057-BCB6-4BDB-9351-12F29393259F\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/section/realestate\" aria-haspopup=\"true\" aria-expanded=\"false\">\nReal Estate\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-CEDDB6A8-F7E1-47A2-AC53-E28C616DFCD5\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/obituaries\">\nObituaries\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-432A1823-3F24-43C0-8004-79088F94E754\" class=\" expandable\" role=\"menuitem\" href=\"https://www.nytimes.com/video\" aria-haspopup=\"true\" aria-expanded=\"false\">\nVideo\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-D64FAE4C-4425-4E5A-B898-6C8CB59F9957\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/upshot\">\nThe Upshot\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"hidden\">\n<a id=\"navId-2745EC29-5385-40F2-93D4-F7E6EF3B518B\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/reader-center\">\nReader Center\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-0442C365-4B63-4B63-B9DE-3C28319CB622\" class=\" expandable\" role=\"menuitem\" tabindex=\"0\" aria-haspopup=\"true\" aria-expanded=\"false\">\nConferences\n\n<div class=\"arrow arrow-right\">\n<div class=\"arrow-conceal\"></div>\n</div>\n\n\n</a>\n</li>\n\n\n\n</ul>\n</div>\n\n<div class=\"section section-more \" data-parent=\"navId-more-section\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-5C13EEDD-D905-4D8C-A284-6859EA434563\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/crosswords\">\nCrossword\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-99C17804-A343-4A76-BF04-F5793ADA48D1\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/reader-center\">\nTimes Insider\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-5B3E3370-B32C-42CD-8D7A-BD96736E3CD0\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/newsletters\">\nNewsletters\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-614CE30F-3D4A-4194-9C6F-AE5901C5762D\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/learning\">\nThe Learning Network\n\n</a>\n</li>\n\n\n\n</ul>\n</div>\n\n<div class=\"section section-more \" data-parent=\"navId-more-section\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-8FB1308A-FFE4-4BED-ADF6-659A680D0884\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/multimedia\">\nMultimedia\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-108F7745-BAD9-4630-87BB-4FB4ED7CAA11\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/lens\">\nPhotography\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-EDCE4B29-2B91-4241-82E6-C972E9449F49\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/spotlight/podcasts\">\nPodcasts\n\n</a>\n</li>\n\n\n\n</ul>\n</div>\n\n<div class=\"section section-more \" data-parent=\"navId-more-section\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-6101A43A-8BDE-45FF-AAD5-EF7396F83AC9\" class=\" \" role=\"menuitem\" href=\"https://store.nytimes.com/?action=click&amp;contentCollection=NYT%20Store&amp;contentPlacement=2&amp;module=SectionsNav&amp;pgtype=Homepage&amp;region=TopBar&amp;t=qry542&amp;utm_campaign=NYT-HP&amp;utm_content=hp_browsetree&amp;utm_medium=HPB&amp;utm_source=nytimes&amp;version=BrowseTree\">\nNYT Store\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-52A8A3F2-F138-425B-A63F-722E2BBC9372\" class=\" \" role=\"menuitem\" href=\"http://www.nytwineclub.com\">\nNYT Wine Club\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-081347DE-FF02-4B6C-889B-9AE59F391833\" class=\" \" role=\"menuitem\" href=\"http://nytedu.com\">\nnytEducation\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-797F8D17-1632-435D-B3DB-708FC4B4BAEF\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/times-journeys/?utm_source=nytimes&amp;utm_medium=HPLink&amp;utm_content=hp_browsetree&amp;utm_campaign=NYT-HP&amp;module=SectionsNav&amp;action=click&amp;region=TopBar&amp;version=BrowseTree&amp;contentCollection=Times%20Journeys&amp;contentPlacement=2&amp;pgtype=Homepage\">\nTimes Journeys\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-53CB229C-5F34-4C32-8B8C-6F7B7626BBDD\" class=\" \" role=\"menuitem\" href=\"https://www.chefd.com/pages/new-york-times-cooking-meal-plan?utm_campaign=web1_20160617&amp;utm_medium=partner&amp;utm_source=nyt\">\nMeal Kits\n\n</a>\n</li>\n\n\n\n</ul>\n</div>\n\n<div class=\"section section-more \" data-parent=\"navId-more-section\">\n<ul class=\"secondary\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-FED853D9-D192-46F6-8D18-447803EB4A7B\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/seeallnav\">\nSubscribe\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-61E9BFEA-F509-4BCA-ADC6-32C5A30B83FD\" class=\" \" role=\"menuitem\" href=\"https://account.nytimes.com\">\nManage Account\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-0DAA7CFE-196B-4878-B899-5363070098EC\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/todayspaper\">\nToday's Paper\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-6BBF5308-5EA3-4B25-885F-393F7372F27F\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/marketing/tools-and-services/\">\nTools &amp; Services\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-288E1691-DA3B-457A-8B06-D10A1351E7B9\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/jobs\">\nJobs\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-D4C7C57A-E74D-44C3-9D0E-0AE6B715610F\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/ref/classifieds/\">\nClassifieds\n\n</a>\n</li>\n\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-6DD9D623-A907-4623-9C5A-9409972B76DA\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/section/corrections\">\nCorrections\n\n</a>\n</li>\n\n\n\n</ul>\n</div>\n</div><!-- close secondary modal -->\n</div>\n<div class=\"tertiary-container\">\n<div class=\"header\">\n<h5 class=\"section-heading\"><a href=\"\" role=\"menuitem\"></a></h5>\n</div>\n\n<ul class=\"tertiary\" data-parent=\"navId-9568A8E4-DD00-4A19-9357-55F8E84ADDB5\" role=\"menu\">\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-B70131F0-6B2A-4A93-8705-0B9F7E9B800F\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/charles-m-blow\">\nCharles M. Blow\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-32A3713A-34A4-4757-8F52-149B4136D9CB\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/jamelle-bouie\">\nJamelle Bouie\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-A2B32B86-C320-49D8-85D3-4AC6BCA2F2C2\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/david-brooks\">\nDavid Brooks\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-1A8CCD43-E5E3-4801-8CBA-0378A0E17530\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/frank-bruni\">\nFrank Bruni\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-A60B44E8-59B1-4687-B20F-D5C71A021C38\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/roger-cohen\">\nRoger Cohen\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-AED55B1F-22EC-45F2-88B6-3B7F340C1949\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/gail-collins\">\nGail Collins\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-6EC4E971-BBD1-4ED5-B61D-E27A3314AE61\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/ross-douthat\">\nRoss Douthat\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-706C9233-C545-4A9E-AB0B-2B6A21C6AF9F\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/maureen-dowd\">\nMaureen Dowd\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-3D56EF48-CA97-4209-A878-6430FB9A2C5E\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/thomas-l-friedman\">\nThomas L. Friedman\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-916CA630-331E-454F-B02E-B00B5959A6E0\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/michelle-goldberg\">\nMichelle Goldberg\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-D6A41F41-19BB-48C6-B121-B89359F1048F\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/nicholas-kristof\">\nNicholas Kristof\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-85905471-3FA0-423F-9D26-1BBE69237899\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/paul-krugman\">\nPaul Krugman\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-A8E6FE07-F530-4197-BA8C-A2A03C27F603\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/david-leonhardt\">\nDavid Leonhardt\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-A31FCCDE-ECDC-49DB-AD6F-635D4ECA34DD\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/farhad-manjoo\">\nFarhad Manjoo\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-86022804-FB5A-4D52-B7FA-758BAE7B67DB\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/jennifer-senior\">\nJennifer Senior\n\n</a>\n</li>\n\n<li role=\"presentation\" class=\"menuitem-visible\">\n<a id=\"navId-3B2FA336-3551-492A-914B-4F11A65FA6BD\" class=\" \" role=\"menuitem\" href=\"https://www.nytimes.com/column/bret-stephens\">\nBret Stephens\n\n</a>\n</li>\n\n</ul>\n\n</div>\n</div>\n<div class=\"modal-footer\">\n\n</div>\n<button type=\"button\" class=\"modal-close hidden\" aria-disabled=\"false\"><i class=\"icon\"></i><span class=\"visually-hidden\">Close this modal window</span></button>\n<div class=\"modal-pointer modal-pointer-left-top\"><div class=\"modal-pointer-conceal\"></div></div>\n</div></div><div id=\"user-profile-modal\" class=\"modal-container user-profile-modal-container\" style=\"display: none;\"><div class=\"overlay\" style=\"display: block;\"></div>\n<div class=\"modal user-profile-modal \" style=\"width: undefined;\" role=\"dialog\" aria-labelledby=\"user-profile-modal-modal-heading\" tabindex=\"-1\">\n<div class=\"modal-header\">\n<h3 class=\"modal-heading\" id=\"user-profile-modal-modal-heading\">Edit Profile</h3>\n<h4 class=\"modal-subheading\">Your profile is public. It will appear with any comments you leave on NYTimes.com</h4>\n</div>\n<div class=\"modal-content\">\n<div class=\"user-profile-form-control form-control user-profile-form-control-loading\">\n\n</div><!-- close user-profile-form-control -->\n</div>\n<div class=\"modal-footer\">\n\n</div>\n<button type=\"button\" class=\"modal-close \" aria-disabled=\"false\"><i class=\"icon\"></i><span class=\"visually-hidden\">Close this modal window</span></button>\n<div class=\"modal-pointer modal-pointer-fixed\"><div class=\"modal-pointer-conceal\"></div></div>\n</div></div><div id=\"verified-modal\" class=\"modal-container verified-modal-container\" style=\"display: none;\"><div class=\"overlay\" style=\"display: none;\"></div>\n<div class=\"modal verified-modal verified-modal\" style=\"width: undefined;\" role=\"dialog\" aria-labelledby=\"verified-modal-modal-heading\" tabindex=\"-1\">\n<div class=\"modal-header\">\n<h3 class=\"modal-heading\" id=\"verified-modal-modal-heading\"></h3>\n\n</div>\n<div class=\"modal-content\">\n<a class=\"faq-link\" href=\"http://www.nytimes.com/content/help/site/usercontent/verified/verified-commenters.html\">\nVerified Commenters\n</a>\ncan leave comments on NYTimes.com without initial moderation. Verified status is earned based on a history of quality comments.\n</div>\n<div class=\"modal-footer\">\n\n</div>\n<button type=\"button\" class=\"modal-close hidden\" aria-disabled=\"false\"><i class=\"icon\"></i><span class=\"visually-hidden\">Close this modal window</span></button>\n<div class=\"modal-pointer modal-pointer-down\"><div class=\"modal-pointer-conceal\"></div></div>\n</div></div></body></html>"}");
|
|
</script>
|