Chloropicrin: Hazards, Uses, Safety, and Regulations Explained
Introduction: When it comes to hazardous chemicals used in agriculture and industry, chloropicrin is always on the list. Even though it is banned in the European Union, it continues to be widely used in the United States—especially as a soil fumigant for strawberry crops. The challenge with chloropicrin is that it is both highly effective […]
Step-by-Step Guide to Reporting a Chemical Spill by CloudSDS
Introduction: Chemical spills are dangerous to human health, safety, and the environment. Small or large, the unrestrained release of dangerous material must be acted on immediately and effectively to reduce harm and avoid further damage. Early reporting of a chemical spill is an essential response step that guarantees effective containment, cleaning up, and regulatory adherence. […]
What are the Different Forms Hazardous Energy Can Take?
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
Comprehensive Guide on Cyanuric Fluoride: Usage, Hazards, and Safety Measures
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PGgyIGlkPSJpbnRyb2R1Y3Rpb24iPkludHJvZHVjdGlvbjwvaDI+CjxwPgpDeWFudXJpYyBmbHVvcmlkZSAoMiw0LDYtdHJpZmx1b3JvLTEsMyw1LXRyaWF6aW5lOyBDQVMgNjc1LTE0LTkpIGlzIGEgY29sb3JsZXNzLCB2b2xhdGlsZSBsaXF1aWQgdXNlZCBwcmltYXJpbHkgYXMgYSBtaWxkIGZsdW9yaW5hdGluZyBhZ2VudCBpbiBvcmdhbmljIHN5bnRoZXNpcyBhbmQgc3BlY2lhbHR5IGNoZW1pY2FsIHByb2R1Y3Rpb24uIER1ZSB0byBpdHMgaGlnaCB0b3hpY2l0eSBhbmQgY29ycm9zaXZpdHksIG1ldGljdWxvdXMgaGFuZGxpbmcgYW5kIHJvYnVzdCBzYWZldHkgbWVhc3VyZXMgYXJlIGVzc2VudGlhbC4gVGhpcyBndWlkZSBjb3ZlcnMgaXRzIGNoZW1pY2FsIHByb3BlcnRpZXMsIGluZHVzdHJpYWwgdXNlcywgcG90ZW50aWFsIGhhemFyZHMsIGFuZCByZWNvbW1lbmRlZCBzYWZldHkgcHJvdG9jb2xzLgo8L3A+Cg==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PGgzIGlkPSJ0cmFuc3BvcnRhdGlvbiI+MTAuIFRyYW5zcG9ydGF0aW9uPC9oMz4KPHVsPgogIDxsaT5VTiAxOTM1LCBDbGFzcyA2LjEgKFRveGljIFN1YnN0YW5jZXMpLCBQYWNraW5nIEdyb3VwIEk8L2xpPgogIDxsaT5TaGlwIGluIGFwcHJvdmVkIGNvcnJvc2l2ZS1yZXNpc3RhbnQgaW5uZXIgcGFja2FnaW5nIHdpdGhpbiBhIHJpZ2lkIG91dGVyIGNvbnRhaW5lci48L2xpPgogIDxsaT5NYXJrIHNoaXBtZW50cyB3aXRoIOKAnFRveGlj4oCdIGFuZCDigJxDb3Jyb3NpdmXigJ0gaGF6YXJkIGxhYmVsczsgbm90aWZ5IGNhcnJpZXJzIG9mIHBvdGVudGlhbCBmb3IgSEYgZ2VuZXJhdGlvbi48L2xpPgo8L3VsPgoKPGgzIGlkPSJyZWd1bGF0b3J5LWNvbnNpZGVyYXRpb25zIj4xMS4gUmVndWxhdG9yeSBDb25zaWRlcmF0aW9uczwvaDM+Cjx1bD4KICA8bGk+UmVwb3J0IGFzIGEgaGlnaGx5IGhhemFyZG91cyBjaGVtaWNhbCB1bmRlciBFUEHigJlzIFJpc2sgTWFuYWdlbWVudCBQcm9ncmFtIChUaHJlc2hvbGQ6IOKJpSAxMDAgbGIpIGR1ZSB0byBwb3RlbnRpYWwgZm9yIGNhdGFzdHJvcGhpYyByZWxlYXNlIG9mIEhGLjwvbGk+CiAgPGxpPlN1YmplY3QgdG8gT1NIQSBIYXphcmQgQ29tbXVuaWNhdGlvbiBTdGFuZGFyZCAoMjkgQ0ZSIDE5MTAuMTIwMCkgYW5kIE5KIFJpZ2h04oCQdG/igJBLbm93IHJlcXVpcmVtZW50cy48L2xpPgogIDxsaT5ET1QgcmVndWxhdGlvbiBhcyBhIHBvaXNvbm91cyBhbmQgY29ycm9zaXZlIHN1YnN0YW5jZS48L2xpPgo8L3VsPgoKPGgzIGlkPSJlbWVyZ2VuY3ktcGxhbm5pbmciPjEyLiBFbWVyZ2VuY3kgUGxhbm5pbmc8L2gzPgo8dWw+CiAgPGxpPkZhY2lsaXRpZXMgaGFuZGxpbmcgJmd0OyAxMDAgbGIgbXVzdCBkZXZlbG9wIFJpc2sgTWFuYWdlbWVudCBQbGFucyAoUk1QcykgY292ZXJpbmcgd29yc3QtY2FzZSByZWxlYXNlIHNjZW5hcmlvcyBvZiBIRi48L2xpPgogIDxsaT5Db29yZGluYXRlIHdpdGggbG9jYWwgZW1lcmdlbmN5IHJlc3BvbmRlcnMgZm9yIGpvaW50IHRyYWluaW5nIGV4ZXJjaXNlcyBvbiBjaGVtaWNhbCByZWxlYXNlIGFuZCBtZWRpY2FsIGNvdW50ZXJtZWFzdXJlcy48L2xpPgo8L3VsPgo=
Chloropicrin and Methyl Bromide Mixture: Usage, Hazards, and Safety
For California’s agricultural commissioners, the “Guidance Manual: Methyl Bromide (In Combination with Chloropicrin) – Field Soil Fumigation” is the go-to resource for vital permit decisions. This essential manual empowers staff to confidently issue restricted materials permits for methyl bromide, strictly adhering to Title 3, Division 6, Subchapter 4 of the California Code of Regulations. It’s […]
Comprehensive Guide to Cyanogen (C₂N₂): Usage, Safety Measures, and Potential Hazards
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PGgyIGlkPSJjb25jbHVzaW9uIj5Db25jbHVzaW9uPC9oMj4KCjxwPgogIFdvcmtpbmcgd2l0aCBjeWFub2dlbiwgYSB2ZXJ5IHRveGljIGNoZW1pY2FsLCBhYnNvbHV0ZWx5IHJlcXVpcmVzIGFuIHVueWllbGRpbmcgY29tbWl0bWVudCB0byB1dG1vc3Qgc2FmZXR5IHByb3RvY29scyB0byBjb3VudGVyYWN0IHRoZSBzZXZlcmUgYWN1dGUgYW5kIGNocm9uaWMgZWZmZWN0cy4KICBJdHMgZGVlcCBhY3V0ZSB0b3hpY2l0eSwgaGF2aW5nIHRoZSBwb3RlbnRpYWwgdG8gY2F1c2UgaW1tZWRpYXRlIGFuZCBzZXZlcmUgcGh5c2lvbG9naWNhbCBkaXN0cmVzcyB0aHJvdWdoIGluaGFsYXRpb24gb3IgY29udGFjdCwgcmVxdWlyZXMgYSB0aG9yb3VnaGx5IGNvbnRhaW5lZCBlbnZpcm9ubWVudCB0byBhdm9pZCBhbnkgcG90ZW50aWFsIGF0bW9zcGhlcmljIHJlbGVhc2Ugb3IgZGlyZWN0IGV4cG9zdXJlLgo8L3A+Cgo8cD4KICBDb21wbGlhbmNlIHdpdGggc3RyaWN0IGNvbnRhaW5tZW50LCBwZXJzb25hbCBwcm90ZWN0aXZlIGVxdWlwbWVudCwgYW5kIGVtZXJnZW5jeSBwcm9jZWR1cmVzIGlzIHJlcXVpcmVkIHdoZW4gaGFuZGxpbmcgY3lhbm9nZW4gdG8gY291bnRlcmFjdCBpdHMgZXh0cmVtZSBhY3V0ZSBhbmQgY2hyb25pYyB0b3hpY2l0eSBlZmZlY3RzLgogIEluIGFkZGl0aW9uLCB0aGUgcG9zc2libGUgaW5zaWRpb3VzIGNocm9uaWMgaGVhbHRoIGltcGFpcm1lbnQgcmVzdWx0aW5nIGZyb20gbG9uZy10ZXJtIG9yIHJlY3VycmluZyBsb3ctaW50ZW5zaXR5IGV4cG9zdXJlIGhpZ2hsaWdodHMgdGhlIGltcGVyYXRpdmUgcm9sZSBvZiBlZmZlY3RpdmUgcGVyc29uYWwgcHJvdGVjdGl2ZSBnZWFyLCBzdWNoIGFzIHNwZWNpYWxpemVkIHJlc3BpcmF0b3JzIGFuZCBpbXBlcm1lYWJsZSBiYXJyaWVyIGNsb3RoaW5nLCB0byBwcm90ZWN0IGFnYWluc3QgYWJzb3JwdGlvbiBhbmQgaW5oYWxhdGlvbi4KPC9wPgoKPHA+CiAgQXBhcnQgZnJvbSB0aGUgcHJldmVudGl2ZSBzYWZldHkgbWVhc3VyZXMsIGRldGFpbGVkIGFuZCBmcmVxdWVudGx5IHByYWN0aWNlZCBlbWVyZ2VuY3kgcHJvY2VkdXJlcyBpbnZvbHZpbmcgc3BpbGwgcmVzcG9uc2UsIGRlY29udGFtaW5hdGlvbiBwcm9jZXNzZXMsIGFuZCBwcm9tcHQgbWVkaWNhbCByZXNwb25zZSBwbGFucyBhcmUgdml0YWwgaW4gcXVpY2tseSByZXNwb25kaW5nIHRvIGFueSB1bmV4cGVjdGVkIGFjY2lkZW50cyBhbmQgcmVzdHJpY3RpbmcgcG9zc2libGUgZGFtYWdlLgogIEluIHRoZSBlbmQsIGFuIGludGVncmFsIGFuZCByaWdvcm91cyBpbXBsZW1lbnRhdGlvbiBvZiB0aGVzZSBpbnRlcnJlbGF0ZWQgc2FmZXR5IHByYWN0aWNlcyBpcyB0aGUgb25seSB3YXkgdG8gYmV0dGVyIGRlYWwgd2l0aCB0aGUgZXh0cmVtZSBhbmQgY29tcGxleCByaXNrcyBpbnZvbHZlZCBpbiB3b3JraW5nIHdpdGggY3lhbm9nZW4uCjwvcD4K
List of Chemical Resistant Workwear | A Detailed Guide
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PHNlY3Rpb24gaWQ9IndoeS1uZWNlc3NhcnkiPgogIDxoMT5XaHkgaXMgQ2hlbWljYWwgUmVzaXN0YW50IFdvcmt3ZWFyIE5lY2Vzc2FyeT88L2gxPgogIDxwPkNoZW1pY2FsLXJlc2lzdGFudCB3b3Jrd2VhciBpcyBuZWNlc3NhcnkgYmVjYXVzZSBpdCBwcm90ZWN0cyB3b3JrZXJzIGZyb20gaGFybWZ1bCBjaGVtaWNhbCBleHBvc3VyZS4gU3VjaCB0eXBlcyBvZiBoYXJtZnVsIGV4cG9zdXJlIGNhbiBjYXVzZSBidXJucywgc2tpbiBpcnJpdGF0aW9uLCBvciBsb25nLXRlcm0gaGVhbHRoIGlzc3Vlcy4gSW4gZW52aXJvbm1lbnRzIHdoZXJlIGNoZW1pY2FscyBhcmUgaGFuZGxlZCBkYWlseSwgc3VjaCBhcyBsYWJvcmF0b3JpZXMsIG1hbnVmYWN0dXJpbmcgcGxhbnRzLCBvciBjbGVhbmluZyBvcGVyYXRpb25zLCBjaGFuY2VzIG9mIGFjY2lkZW50YWwgc3BpbGxzIGFyZSBhbHdheXMgaGlnaC4gUmVndWxhciBjbG90aGluZyBjYW5ub3Qgc3RvcCB0aGVzZSBzdWJzdGFuY2VzIGZyb20gcmVhY2hpbmcgdGhlIHNraW4sIHdoaWNoIGlzIHdoeSBzcGVjaWFsbHkgZGVzaWduZWQgcHJvdGVjdGl2ZSBnZWFyIGlzIGVzc2VudGlhbC48L3A+CgogIDxwPldlYXJpbmcgY2hlbWljYWwgcmVzaXN0YW50IHdvcmt3ZWFyIGFsc28gaGVscHMgb3JnYW5pemF0aW9ucyBzdGF5IGNvbXBsaWFudC4gQXMgYSByZXN1bHQsIG9yZ2FuaXphdGlvbnMgY2FuIGVhc2lseSBzdGF5IGF3YXkgZnJvbSBzYWZldHkgcmVndWxhdGlvbnMgYW5kIGF2b2lkIGxlZ2FsIHBlbmFsdGllcy4gSXQgc2hvd3MgYSBjb21taXRtZW50IHRvIGVtcGxveWVlIHNhZmV0eS4gQmVzaWRlcywgaXQgcmVkdWNlcyB0aGUgcmlzayBvZiB3b3JrcGxhY2UgYWNjaWRlbnRzLiBNb3N0IGltcG9ydGFudGx5LCBpdCBlbnN1cmVzIHRoYXQgd29ya2VycyBmZWVsIGNvbmZpZGVudCBhbmQgcHJvdGVjdGVkIHdoaWxlIGRvaW5nIHRoZWlyIGpvYnMuPC9wPgo8L3NlY3Rpb24+Cg==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PHNlY3Rpb24gaWQ9ImJ1eWluZy1jb25zaWRlcmF0aW9ucyI+CiAgPGgyPldoYXQgc2hvdWxkIHlvdXIgQ29tcGFueSBDb25zaWRlciB3aGlsZSBCdXlpbmcgdGhlIFdvcmt3ZWFyPzwvaDI+CiAgPHA+QmVmb3JlIHlvdSBwdXJjaGFzZSwgY29uc2lkZXIgdGhlIGZvbGxvd2luZyBwb2ludHM6PC9wPgogIDx1bD4KICAgIDxsaT48c3Ryb25nPlVzZSBTRFNzPC9zdHJvbmc+IHRvIGNoZWNrIHdoYXQgZWFjaCBjaGVtaWNhbCByZXF1aXJlcy4gWW91IG11c3QgbWF0Y2ggeW91ciBQUEUgd2l0aCB5b3VyIGNoZW1pY2FsIGludmVudG9yeS48L2xpPgogICAgPGxpPjxzdHJvbmc+Q2hvb3NlIGRpc3Bvc2FibGUgb3IgcmV1c2FibGUgd2lzZWx5Ljwvc3Ryb25nPiBEaXNwb3NhYmxlIGlzIHNhZmVyIGZvciBoaWdoLXJpc2sgdGFza3MuIE9uIHRoZSBvdGhlciBoYW5kLCByZXVzYWJsZSBpcyBlY29ub21pY2FsIGZvciByb3V0aW5lIGxvdy1leHBvc3VyZSB3b3JrLjwvbGk+CiAgICA8bGk+PHN0cm9uZz5UcmFpbiBlbXBsb3llZXM8L3N0cm9uZz4gb24gaG93IHRvIHdlYXIgb3IgdXNlIHRoZSB3b3Jrd2Vhci4gRWFjaCBpbmNvcnJlY3QgdXNlIGxlYWRzIHRvIGV4cG9zdXJlLjwvbGk+CiAgICA8bGk+PHN0cm9uZz5Eb27igJl0IGlnbm9yZSByZWd1bGFyIGluc3BlY3Rpb24uPC9zdHJvbmc+IFJlZ3VsYXIgYXVkaXQgaGVscHMgeW91IGZpbmQgb3V0IGRhbWFnZXMgZWFybHkuPC9saT4KICA8L3VsPgo8L3NlY3Rpb24+Cg==PHNlY3Rpb24gaWQ9ImNvbmNsdXNpb24iPgogIDxoMj5Db25jbHVzaW9uPC9oMj4KICA8cD5DaGVtaWNhbC1yZXNpc3RhbnQgd29ya3dlYXIgaXMgYW4gZXNzZW50aWFsIHRvb2wgdGhhdCBvcmdhbml6YXRpb25zIGhhbmRsaW5nIGNoZW1pY2FsIHByb2R1Y3RzIG5lZWQgdG8gc3RvcmUuIEhvd2V2ZXIsIGNob29zaW5nIHRoZSByaWdodCBnZWFyIGlzIG5lY2Vzc2FyeS4gSXQgcHJldmVudHMgaW5qdXJ5LCBoZWxwcyB5b3UgYXZvaWQgZmluZXMsIGFuZCBpbiB0aGUgZW5kLCBidWlsZHMgYSBjdWx0dXJlIG9mIHNhZmV0eS4gV2hldGhlciB5b3UncmUgYSBzbWFsbCBsYWIgb3IgYSBnbG9iYWwgbWFudWZhY3R1cmVyLCBpbnZlc3RpbmcgaW4gY2VydGlmaWVkLCB0YXNrLXNwZWNpZmljIFBQRSBpcyBvbmUgb2YgdGhlIHNtYXJ0ZXN0IGRlY2lzaW9ucyB5b3UgY2FuIG1ha2UuPC9wPgo8L3NlY3Rpb24+Cg==
Comprehensive Guide on Safety Programs for Manufacturing
PGgyPlRhYmxlIG9mIENvbnRlbnRzPC9oMj4KPG9sPgogIDxsaT48YSBocmVmPSIjaW50cm9kdWN0aW9uIj5JbnRyb2R1Y3Rpb248L2E+PC9saT4KICA8bGk+PGEgaHJlZj0iI3VuZGVyc3RhbmRpbmctc2FmZXR5LXByb2dyYW1zIj5VbmRlcnN0YW5kaW5nIFNhZmV0eSBQcm9ncmFtcyBmb3IgTWFudWZhY3R1cmluZzwvYT48L2xpPgogIDxsaT48YSBocmVmPSIjaW50cm8tdG8tc2FmZXR5LXByb2dyYW1zIj4xLiBJbnRyb2R1Y3Rpb24gdG8gTWFudWZhY3R1cmluZyBTYWZldHkgUHJvZ3JhbXM8L2E+PC9saT4KICA8bGk+PGEgaHJlZj0iI3JlZ3VsYXRvcnktZnJhbWV3b3JrIj4yLiBSZWd1bGF0b3J5IGFuZCBTdGFuZGFyZHMgRnJhbWV3b3JrPC9hPgogICAgPHVsPgogICAgICA8bGk+PGEgaHJlZj0iI29zaGEtc3RhbmRhcmRzIj5hLiBPU0hBIFN0YW5kYXJkczwvYT48L2xpPgogICAgICA8bGk+PGEgaHJlZj0iI2lzby00NTAwMSI+Yi4gSVNPIDQ1MDAxPC9hPjwvbGk+CiAgICA8L3VsPgogIDwvbGk+CiAgPGxpPjxhIGhyZWY9IiNjb3JlLWVsZW1lbnRzIj4zLiBDb3JlIEVsZW1lbnRzIG9mIGFuIEVmZmVjdGl2ZSBTYWZldHkgUHJvZ3JhbTwvYT4KICAgIDx1bD4KICAgICAgPGxpPjxhIGhyZWY9IiNsZWFkZXJzaGlwIj5hLiBMZWFkZXJzaGlwIENvbW1pdG1lbnQgYW5kIFBvbGljeTwvYT48L2xpPgogICAgICA8bGk+PGEgaHJlZj0iI3Jpc2stYXNzZXNzbWVudCI+Yi4gUmlzayBBc3Nlc3NtZW50IGFuZCBIYXphcmQgSWRlbnRpZmljYXRpb248L2E+PC9saT4KICAgICAgPGxpPjxhIGhyZWY9IiNzYWZldHktcHJvY2VkdXJlcyI+Yy4gU2FmZXR5IFByb2NlZHVyZXMgYW5kIENvbnRyb2xzPC9hPjwvbGk+CiAgICAgIDxsaT48YSBocmVmPSIjdHJhaW5pbmciPmQuIFRyYWluaW5nIGFuZCBDb21wZXRlbmN5IERldmVsb3BtZW50PC9hPjwvbGk+CiAgICAgIDxsaT48YSBocmVmPSIjY29tbXVuaWNhdGlvbiI+ZS4gQ29tbXVuaWNhdGlvbiBhbmQgRW1wbG95ZWUgSW52b2x2ZW1lbnQ8L2E+PC9saT4KICAgICAgPGxpPjxhIGhyZWY9IiNpbmNpZGVudC1pbnZlc3RpZ2F0aW9uIj5mLiBJbmNpZGVudCBJbnZlc3RpZ2F0aW9uIGFuZCBDb3JyZWN0aXZlIEFjdGlvbjwvYT48L2xpPgogICAgICA8bGk+PGEgaHJlZj0iI21vbml0b3JpbmciPmcuIE1vbml0b3JpbmcsIEF1ZGl0cywgYW5kIFBlcmZvcm1hbmNlIE1ldHJpY3M8L2E+PC9saT4KICAgICAgPGxpPjxhIGhyZWY9IiNjb250aW51b3VzLWltcHJvdmVtZW50Ij5oLiBDb250aW51b3VzIEltcHJvdmVtZW50IGFuZCBTYWZldHkgQ3VsdHVyZTwvYT48L2xpPgogICAgPC91bD4KICA8L2xpPgogIDxsaT48YSBocmVmPSIjcmlzay1tZXRob2RzIj40LiBSaXNrIEFzc2Vzc21lbnQgTWV0aG9kb2xvZ2llczwvYT48L2xpPgogIDxsaT48YSBocmVmPSIjdHJhaW5pbmctZGVzaWduIj41LiBUcmFpbmluZyBQcm9ncmFtIERlc2lnbjwvYT48L2xpPgogIDxsaT48YSBocmVmPSIjdGVjaG5vbG9neSI+Ni4gTGV2ZXJhZ2luZyBUZWNobm9sb2d5IGFuZCBJbm5vdmF0aW9uPC9hPjwvbGk+CiAgPGxpPjxhIGhyZWY9IiNpbXBsZW1lbnRhdGlvbi1yb2FkbWFwIj43LiBQcm9ncmFtIEltcGxlbWVudGF0aW9uIFJvYWRtYXA8L2E+PC9saT4KICA8bGk+PGEgaHJlZj0iI2Nhc2Utc3R1ZHkiPjguIENhc2UgU3R1ZHk6IElTTyA0NTAwMSBpbiBBY3Rpb248L2E+PC9saT4KICA8bGk+PGEgaHJlZj0iI21lYXN1cmluZy1zdWNjZXNzIj45LiBNZWFzdXJpbmcgU3VjY2VzcyBhbmQgU3VzdGFpbmluZyBNb21lbnR1bTwvYT48L2xpPgogIDxsaT48YSBocmVmPSIjY29uY2x1c2lvbiI+Q29uY2x1c2lvbjwvYT48L2xpPgo8L29sPgo=PGgyIGlkPSJpbnRyb2R1Y3Rpb24iPkludHJvZHVjdGlvbjwvaDI+Cgo8cD4KSW5kdXN0cmlhbCBzYWZldHkgaXNuJ3QganVzdCBhIHJ1bGU7IGl0J3MgdGhlIGJlZHJvY2sgb2YgbWFudWZhY3R1cmluZyBzdWNjZXNzLiBNb3ZpbmcgYmV5b25kIHJlYWN0aXZlIGluY2lkZW50IHJlc3BvbnNlLCB0cnVlIHNhZmV0eSBlbWJlZHMgcHJvYWN0aXZlIGhhemFyZCBwcmV2ZW50aW9uIGludG8gZXZlcnkgb3BlcmF0aW9uLCBhY2tub3dsZWRnaW5nIHRoYXQgZXZlcnkgaW5qdXJ5IG9yIG5lYXIgbWlzcyBkaXJlY3RseSBpbXBhY3RzIHByb2R1Y3Rpb24sIGVtcGxveWVlIG1vcmFsZSwgYW5kIHRoZSBib3R0b20gbGluZS4gSXQncyBzaW1wbHkgYWJvdXQ6CjwvcD4KCjx1bD4KICA8bGk+Q3VsdGl2YXRpbmcgZGFpbHkgaGFiaXRzPC9saT4KICA8bGk+SWRlbnRpZnlpbmcgcmlza3M8L2xpPgogIDxsaT5FbnN1cmluZyBldmVyeSB3b3JrZXIgZ2V0cyBob21lIHNhZmVseTwvbGk+CiAgPGxpPk1hbmRhdGluZyBjb25zaXN0ZW50IHByb3RvY29scywgYW5kPC9saT4KICA8bGk+VHJhaW5pbmcgdHVybmluZyBjb21wbGlhbmNlIGludG8gYSBjb21wZXRpdGl2ZSBlZGdlPC9saT4KPC91bD4KCjxwPgpQcmlvcml0aXppbmcgc2FmZXR5IGJ1aWxkcyBhIHJlc2lsaWVudCB3b3JrZm9yY2UgYW5kIGEgcm9idXN0IG9wZXJhdGlvbiwgcHJvdmluZyB0aGF0IHByb2FjdGl2ZSBwcm90ZWN0aW9uIGFsd2F5cyBwYXlzIG9mZi4KPC9wPgo=PGgxIGlkPSJ1bmRlcnN0YW5kaW5nLXNhZmV0eS1wcm9ncmFtcyI+VW5kZXJzdGFuZGluZyBTYWZldHkgUHJvZ3JhbXMgZm9yIE1hbnVmYWN0dXJpbmc8L2gxPgoKPHA+CkEgcm9idXN0IHNhZmV0eSBwcm9ncmFtIGluIG1hbnVmYWN0dXJpbmcgbm90IG9ubHkgcHJvdGVjdHMgZW1wbG95ZWVzIGFuZCBlbnN1cmVzIHJlZ3VsYXRvcnkgY29tcGxpYW5jZSBidXQgYWxzbyBkcml2ZXMgb3BlcmF0aW9uYWwgZXhjZWxsZW5jZSwgcmVkdWNlcyBjb3N0cyBhc3NvY2lhdGVkIHdpdGggaW5qdXJpZXMsIGFuZCBmb3N0ZXJzIGEgY3VsdHVyZSBvZiBjb250aW51b3VzIGltcHJvdmVtZW50Lgo8L3A+Cg==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
Comprehensive Guide to Safe Storage of Flammable Liquids
PGgyPlRhYmxlIG9mIENvbnRlbnRzPC9oMj4KPG9sPgogIDxsaT48YSBocmVmPSIjaW50cm9kdWN0aW9uIj5JbnRyb2R1Y3Rpb248L2E+PC9saT4KICA8bGk+PGEgaHJlZj0iI3N0b3JhZ2UtbG9jYXRpb24iPldoZXJlIFNob3VsZCBGbGFtbWFibGUgTGlxdWlkcyBCZSBTdG9yZWQ8L2E+PC9saT4KICA8b2wgdHlwZT0iQSI+CiAgICA8bGk+PGEgaHJlZj0iI2NsYXNzaWZpY2F0aW9uIj5DbGFzc2lmaWNhdGlvbiBvZiBGbGFtbWFibGUgTGlxdWlkczwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNxdWFudGl0eS1zdG9yYWdlIj5RdWFudGl0eSBMaW1pdHMgYW5kIFN0b3JhZ2UgTG9jYXRpb25zPC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI3NlcGFyYXRpb24iPlNlcGFyYXRpb24gZnJvbSBJZ25pdGlvbiBTb3VyY2VzIGFuZCBJbmNvbXBhdGlibGVzPC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI3ZlbnRpbGF0aW9uIj5WZW50aWxhdGlvbiBhbmQgVGVtcGVyYXR1cmUgQ29udHJvbDwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNvdXRkb29yLXN0b3JhZ2UiPk91dGRvb3IgU3RvcmFnZSBhbmQgQnVsayBUYW5rczwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNoYW5kbGluZy10cmFuc2ZlciI+SGFuZGxpbmcgYW5kIFRyYW5zZmVyIFByYWN0aWNlczwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNhZG1pbi1jb250cm9scyI+QWRtaW5pc3RyYXRpdmUgQ29udHJvbHMgYW5kIFRyYWluaW5nPC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI2ZpcmUtcHJvdGVjdGlvbiI+RmlyZSBQcm90ZWN0aW9uIGFuZCBFbWVyZ2VuY3kgUHJlcGFyZWRuZXNzPC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI3NwZWNpYWwtY29uc2lkZXJhdGlvbnMiPlNwZWNpYWwgQ29uc2lkZXJhdGlvbnM8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjYmVzdC1wcmFjdGljZXMiPlN1bW1hcnkgb2YgQmVzdCBQcmFjdGljZXM8L2E+PC9saT4KICA8L29sPgo8L29sPgo=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PGgzIGlkPSJzZXBhcmF0aW9uIj4zLiBTZXBhcmF0aW9uIGZyb20gSWduaXRpb24gU291cmNlcyBhbmQgSW5jb21wYXRpYmxlczwvaDM+Cgo8aDQ+My4xIElnbml0aW9uIFNvdXJjZSBDb250cm9sPC9oND4KPHVsPgogIDxsaT5Qcm9oaWJpdCBzbW9raW5nLCBvcGVuIGZsYW1lcywgYW5kIGhvdCB3b3JrIG5lYXIgc3RvcmFnZS48L2xpPgogIDxsaT5Vc2UgaW50cmluc2ljYWxseSBzYWZlIGVsZWN0cmljYWwgZXF1aXBtZW50IGluIGNsYXNzaWZpZWQgem9uZXMuPC9saT4KICA8bGk+VXNlIGJvbmRpbmcgYW5kIGdyb3VuZGluZyBkdXJpbmcgdHJhbnNmZXJzIHRvIHByZXZlbnQgc3RhdGljIHNwYXJrcy48L2xpPgo8L3VsPgoKPGg0PjMuMiBDaGVtaWNhbCBTZWdyZWdhdGlvbjwvaDQ+Cjx1bD4KICA8bGk+U2VwYXJhdGUgZmxhbW1hYmxlcyBmcm9tIG94aWRpemVycywgYWNpZHMsIGJhc2VzLCBhbmQgd2F0ZXItcmVhY3RpdmVzLjwvbGk+CiAgPGxpPk1haW50YWluIGRlZGljYXRlZCBjYWJpbmV0cyBvciBzZWdyZWdhdGVkIGFyZWFzIHBlciBjb21wYXRpYmlsaXR5IGNoYXJ0cy48L2xpPgogIDxsaT5Vc2Ugc2Vjb25kYXJ5IGNvbnRhaW5tZW50IGZvciBzcGlsbCBjb250cm9sLjwvbGk+CjwvdWw+Cg==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
How to Choose the Best Laboratory Safety Goggles: A B2B Buyer’s Guide
PG5hdiBpZD0idGFibGUtb2YtY29udGVudHMiPgogIDxoMj5UYWJsZSBvZiBDb250ZW50czwvaDI+CiAgPHVsPgogICAgPGxpPjxhIGhyZWY9IiNpbnRyb2R1Y3Rpb24iPkludHJvZHVjdGlvbjwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiN3aHktc2FmZXR5LWdvZ2dsZXMtbWF0dGVyIj5XaHkgTGFib3JhdG9yeSBTYWZldHkgR29nZ2xlcyBNYXR0ZXI8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjc2FmZXR5LXN0YW5kYXJkcyI+T1NIQSBhbmQgQU5TSSBTdGFuZGFyZHMgWW914oCZbGwgV2FudCB0byBLbm93IEFib3V0PC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI2hhemFyZC1pZGVudGlmaWNhdGlvbiI+MS4gSWRlbnRpZnkgdGhlIEhhemFyZHMgaW4gWW91ciBMYWI8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjZ29nZ2xlLXR5cGVzIj4yLiBVbmRlcnN0YW5kIHRoZSBEaWZmZXJlbnQgQ2F0ZWdvcmllcyBvZiBHb2dnbGVzPC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI21hdGVyaWFscyI+My4gTWF0ZXJpYWwgRmFjdG9yczwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNjb2F0aW5ncyI+NC4gQW50aS1TY3JhdGNoIGFuZCBBbnRpLUZvZyBDb2F0aW5nczwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNjb21mb3J0LWZpdCI+NS4gQ29tZm9ydCBhbmQgRml0OiBBbiBJbXBvcnRhbnQgQXNwZWN0PC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI290ZyI+Ni4gT1RHIENvbXBhdGliaWxpdHkgYW5kIFByZXNjcmlwdGlvbiBTYWZldHkgR2xhc3NlczwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNpbmR1c3RyeS1zcGVjaWZpYyI+Ny4gSW5kdXN0cnktU3BlY2lmaWMgU3VnZ2VzdGlvbnM8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjYnVsay1wdXJjaGFzaW5nIj44LiBCdWxrIFB1cmNoYXNpbmcgUmVjb21tZW5kYXRpb25zIGZvciBCMkIgQ3VzdG9tZXJzPC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI21haW50ZW5hbmNlIj45LiBHdWlkZWxpbmVzIGZvciBNYWludGVuYW5jZSBhbmQgUmVwbGFjZW1lbnQ8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjY29uY2x1c2lvbiI+Q29uY2x1c2lvbjwvYT48L2xpPgogIDwvdWw+CjwvbmF2Pgo=PGgyIGlkPSJpbnRyb2R1Y3Rpb24iPkludHJvZHVjdGlvbjwvaDI+Cgo8cD5FeWUgUHJvdGVjdGlvbiBpcyBtYW5kYXRvcnkgYW5kIHNhZmV0eSBsZWdpc2xhdGlvbiBpbiBjaGVtaWNhbCBsYWJvcmF0b3JpZXMsIHJlc2VhcmNoIGZhY2lsaXRpZXMsIG1hbnVmYWN0dXJpbmcgcGxhbnRzLiBPbmUgb2YgdGhlIG1vc3QgY29tbW9uIHdvcmtwbGFjZSBhY2NpZGVudHMgaXMgZXllIGluanVyeSwgd2hpY2ggaXMgY29tbW9ubHkgY2F1c2VkIGJ5IGFpcmJvcm5lIHBhcnRpY2xlcywgY2hlbWljYWwgc3BsYXNoZXMsIG9yIFVWIGxpZ2h0aW5nLiBTZWxlY3RpbmcgdGhlIHJpZ2h0IGxhYm9yYXRvcnkgc2FmZXR5IGdvZ2dsZXMgbWF0dGVycyBmb3IgRUhTIG1hbmFnZXJzLCBsYWIgbWFuYWdlcnMsIGFuZCBwcm9jdXJlbWVudCBvZmZpY2VycyBmb3IgbW9yZSB0aGFuIGp1c3QgT1NIQSBvciBBTlNJIGNvbXBsaWFuY2UuIEFtb25nIHRoZXNlIHJlYXNvbnMgYXJlIHN1c3RhaW5pbmcgcHJvZHVjdGl2aXR5LCByZWR1Y2luZyBsaWFiaWxpdHksIGFuZCBlbmhhbmNpbmcgdGhlIHdlbGwtYmVpbmcgb2YgZW1wbG95ZWVzLjwvcD4KCjxwPjxzdHJvbmc+V2hhdCBtYXR0ZXJzOjwvc3Ryb25nPiBBTlNJLyBPU0hBLCBtYXRlcmlhbCwgY29hdGluZ3MsIGZpdCDigJMgYW5kIHJlY29tbWVuZGF0aW9ucyBmb3IgY2hlbWljYWwgbWFudWZhY3R1cmluZywgYmlvdGVjaCwgYW5kIHBoYXJtYSBhcmUgYWxsIGluY2x1ZGVkIGluIHRoaXMgQjJCIGd1aWRlLjwvcD4KCjxoMSBpZD0id2h5LXNhZmV0eS1nb2dnbGVzLW1hdHRlciI+V2h5IExhYm9yYXRvcnkgU2FmZXR5IEdvZ2dsZXMgTWF0dGVyPC9oMT4KCjxwPlRoZXJlIGFyZSBtb3JlIHRoYW4gMjAsMDAwIHdvcmtwbGFjZSBleWUgaW5qdXJpZXMgYW5udWFsbHksIGFjY29yZGluZyB0byB0aGUgVS5TLiBCdXJlYXUgb2YgTGFib3IgU3RhdGlzdGljcy4gTW9zdCBvZiB0aGVzZSBjYW4gYmUgcHJldmVudGVkIGJ5IHdlYXJpbmcgPGEgaHJlZj0iaHR0cHM6Ly9jbG91ZHNkcy5jb20vYmxvZy9ob3ctdG8tc2VsZWN0LXRoZS1yaWdodC1wZXJzb25hbC1wcm90ZWN0aXZlLWVxdWlwbWVudC1wcGUtZm9yLWFueS1qb2IvIiB0YXJnZXQ9Il9ibGFuayIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIj5wZXJzb25hbCBwcm90ZWN0aXZlIGVxdWlwbWVudCAoUFBFKTwvYT4sIHN1Y2ggYXMgc2FmZXR5IGdvZ2dsZXMuIEZvciBidXNpbmVzcy10by1idXNpbmVzcyBlbnRlcnByaXNlcyB1c2luZyBkYW5nZXJvdXMgY2hlbWljYWxzLCBoaWdoLXByZXNzdXJlIHN5c3RlbXMsIGFuZCBsYXNlcnMsIGEgbGFjayBvZiBwcm90ZWN0aW9uIGNvdWxkIHJlc3VsdCBpbiBmaW5lcywgbG9zcyBvZiBwcm9kdWN0aXZpdHksIGFuZCBsYXN0aW5nIGxvc3Mgb2YgZXllc2lnaHQuPC9wPgo=PGgyIGlkPSJzYWZldHktc3RhbmRhcmRzIj5TdGFuZGFyZHMgdG8gQmUgQXdhcmUgb2YgT1NIQSBhbmQgQU5TSSBTdGFuZGFyZHMgWW914oCZbGwgV2FudCB0byBLbm93IEFib3V0PC9oMj4KCjxwPkJlZm9yZSBkZWNpZGluZyBvbiBsYWIgZ29nZ2xlcywgc2FmZXR5IG1hbmFnZXJzIG11c3QgYmUgc3VyZSB0aGV5IG1lZXQgdGhlIEFOU0kgWjg3LjEtMjAyMCBzdGFuZGFyZC4gVGhpcyBpcyB0aGUgc3RhbmRhcmQgZm9yIGltcGFjdCBpbiB0aGUgVVMsIGJ1dCBpdCBpcyBhbHNvIHVzZWQgZm9yIHNwbGFzaCBhbmQgb3B0aWNhbCBjbGFyaXR5LiBOb3cgaXQgaXMgd29ydGggbm90aW5nIHRoYXQgT1NIQSBnb2VzIGJ5IEFOU0kgWjg3LjEgZm9yIHRoZSBlbmZvcmNlbWVudCBvZiBzYWZldHkgZXlld2VhciB2aW9sYXRpb25zIGFzIHBlciAyOSBDRlIgMTkxMC4xMzMuPC9wPgoKPHA+PHN0cm9uZz5LZXkgQU5TSSBaODcuMSBHb2dnbGUgTWFya2luZ3MgSW5jbHVkZTo8L3N0cm9uZz48L3A+Cjx1bD4KICA8bGk+PHN0cm9uZz5aODcrPC9zdHJvbmc+IOKAkyBIaWdoLWltcGFjdCByYXRlZDwvbGk+CiAgPGxpPjxzdHJvbmc+RDM8L3N0cm9uZz4g4oCTIFNwbGFzaCBhbmQgZHJvcGxldCBwcm90ZWN0aW9uPC9saT4KICA8bGk+PHN0cm9uZz5VNjwvc3Ryb25nPiDigJMgVVYgZmlsdGVyIHVwIHRvIDQwMCBubTwvbGk+CiAgPGxpPjxzdHJvbmc+UjU8L3N0cm9uZz4g4oCTIEluZnJhcmVkIHByb3RlY3Rpb248L2xpPgogIDxsaT48c3Ryb25nPkw8L3N0cm9uZz4g4oCTIEZpbHRlciBhZ2FpbnN0IHZpc2libGUgbGlnaHQgKHN1Y2ggYXMgcHJvdGVjdGlvbiBhZ2FpbnN0IGxhc2VyKTwvbGk+CjwvdWw+Cgo8cD5Gb3IgbGFib3JhdG9yeSBlbnZpcm9ubWVudHMsIHRoZSBEMyBtYXJraW5nIGlzIG1hbmRhdG9yeSBpbiB0aGUgY2FzZSBvZiBaODcrLjwvcD4=PGgzIGlkPSJoYXphcmQtaWRlbnRpZmljYXRpb24iPjEuIElkZW50aWZ5IHRoZSBIYXphcmRzIGluIFlvdXIgTGFiPC9oMz4KCjxwPlJpc2tzIGRpdmVyZ2UgYW1vbmdzdCBsYWJvcmF0b3JpZXMuIEEgZ29nZ2xlIGRlc2lnbmVkIGZvciBhIHVuaXZlcnNpdHkgY2hlbWlzdHJ5IGxhYiBtaWdodCBub3QgZnVuY3Rpb24gaW4gYW4gaW5kdXN0cmlhbCBSJkQgY2VudGVyIG9yIGJpb3BoYXJtYSBjbGVhbnJvb20uIFRvIGRldGVybWluZSB0aGUga2luZHMgb2Ygcmlza3MgaW52b2x2ZWQsIGRvIGEgd29ya3BsYWNlIGhhemFyZCBhc3Nlc3NtZW50OjwvcD4KCjxzdHlsZT4KICB0YWJsZS5zdHlsZWQtdGFibGUgewogICAgd2lkdGg6IDEwMCU7CiAgICBib3JkZXItY29sbGFwc2U6IGNvbGxhcHNlOwogICAgbWFyZ2luLXRvcDogMWVtOwogICAgZm9udC1mYW1pbHk6IEFyaWFsLCBzYW5zLXNlcmlmOwogIH0KICB0YWJsZS5zdHlsZWQtdGFibGUgdGgsCiAgdGFibGUuc3R5bGVkLXRhYmxlIHRkIHsKICAgIGJvcmRlcjogMXB4IHNvbGlkICNjY2M7CiAgICBwYWRkaW5nOiAxMnB4IDE2cHg7CiAgICB0ZXh0LWFsaWduOiBsZWZ0OwogIH0KICB0YWJsZS5zdHlsZWQtdGFibGUgdGhlYWQgewogICAgYmFja2dyb3VuZC1jb2xvcjogI2YyZjJmMjsKICAgIGZvbnQtd2VpZ2h0OiBib2xkOwogIH0KICB0YWJsZS5zdHlsZWQtdGFibGUgdGJvZHkgdHI6bnRoLWNoaWxkKGV2ZW4pIHsKICAgIGJhY2tncm91bmQtY29sb3I6ICNmYWZhZmE7CiAgfQo8L3N0eWxlPgoKPHRhYmxlIGNsYXNzPSJzdHlsZWQtdGFibGUiPgogIDx0aGVhZD4KICAgIDx0cj4KICAgICAgPHRoPlR5cGUgb2YgSGF6YXJkPC90aD4KICAgICAgPHRoPlN1Z2dlc3RlZCBGZWF0dXJlPC90aD4KICAgIDwvdHI+CiAgPC90aGVhZD4KICA8dGJvZHk+CiAgICA8dHI+CiAgICAgIDx0ZD5TcGxhc2hlcyBvZiBjaGVtaWNhbHM8L3RkPgogICAgICA8dGQ+R29nZ2xlcyB0aGF0IGFyZSBzZWFsZWQgYW5kIGhhdmUgaW5kaXJlY3QgdmVudGlsYXRpb24sIEQzLjwvdGQ+CiAgICA8L3RyPgogICAgPHRyPgogICAgICA8dGQ+UGFydGljbGUgaW1wYWN0PC90ZD4KICAgICAgPHRkPlo4NysgcG9seWNhcmJvbmF0ZSBsZW5zZXMuPC90ZD4KICAgIDwvdHI+CiAgICA8dHI+CiAgICAgIDx0ZD5FeHBvc3VyZSB0byBsYXNlcnM8L3RkPgogICAgICA8dGQ+R29nZ2xlcyB3aXRoIHdhdmVsZW5ndGggZmlsdGVycyB0aGF0IGFyZSBsYXNlci1yYXRlZDwvdGQ+CiAgICA8L3RyPgogICAgPHRyPgogICAgICA8dGQ+RXhwb3N1cmUgdG8gVVYvSVI8L3RkPgogICAgICA8dGQ+VVYvSVIgZmlsdGVyaW5nIGxlbnNlczwvdGQ+CiAgICA8L3RyPgogICAgPHRyPgogICAgICA8dGQ+Q29uZGl0aW9ucyB0aGF0IGFyZSBwcm9uZSB0byBmb2c8L3RkPgogICAgICA8dGQ+R29vZCB2ZW50aWxhdGlvbiBhbmQgYW50aS1mb2cgY29hdGluZzwvdGQ+CiAgICA8L3RyPgogIDwvdGJvZHk+CjwvdGFibGU+Cg==PGgzIGlkPSJnb2dnbGUtdHlwZXMiPjIuIFVuZGVyc3RhbmQgdGhlIERpZmZlcmVudCBDYXRlZ29yaWVzIG9mIEdvZ2dsZXM8L2gzPgoKPHA+VGhlIG1hbnVmYWN0dXJpbmcgcHJvY2VzcyBvZiBnb2dnbGVzIGRpZmZlcnMuIERlcGVuZGluZyBvbiB5b3VyIHVzZSBzaXR1YXRpb24sIHlvdSBtaWdodCByZXF1aXJlOjwvcD4KCjx1bD4KICA8bGk+PHN0cm9uZz5TYWZldHkgZ29nZ2xlcyBmb3IgaW5kaXJlY3QgdmVudHM8L3N0cm9uZz48YnI+CiAgQWxsb3cgYWlyZmxvdyB3aGlsZSBwcmV2ZW50aW5nIGxpcXVpZCBzcGxhc2hlcy48YnI+CiAgUGVyZmVjdCBmb3IgY2hlbWljYWwgbGFib3JhdG9yaWVzLjwvbGk+CgogIDxsaT48c3Ryb25nPlNhZmV0eSBnb2dnbGVzIGZvciBkaXJlY3QgdmVudHM8L3N0cm9uZz48YnI+CiAgSW5jcmVhc2UgYWlyZmxvdyBhcyBtdWNoIGFzIHBvc3NpYmxlIGJ1dCBhdm9pZCBzcGxhc2ggaGF6YXJkcy48YnI+CiAgT25seSB1c2VmdWwgaW4gZHVzdHkgZW52aXJvbm1lbnRzLjwvbGk+CgogIDxsaT48c3Ryb25nPlNhZmV0eSBnb2dnbGVzIHdpdGhvdXQgdmVudHM8L3N0cm9uZz48YnI+CiAgSWRlYWwgZm9yIG1hbmFnaW5nIGV4dHJlbWVseSBoYXphcmRvdXMgb3IgY29ycm9zaXZlIHN1YnN0YW5jZXMuPGJyPgogIExpbWl0ZWQgYWlyZmxvdyBtYWtlcyBpdCBsZXNzIGNvbWZvcnRhYmxlIHRvIHdlYXIgZm9yIGV4dGVuZGVkIHBlcmlvZHMuPC9saT4KCiAgPGxpPjxzdHJvbmc+TGFzZXIgc2FmZXR5IGdvZ2dsZXM8L3N0cm9uZz48YnI+CiAgT2ZmZXIgcHJvdGVjdGlvbiBhZ2FpbnN0IHNwZWNpZmljIGxhc2VyIHdhdmVsZW5ndGhzLjxicj4KICBNdXN0IGJlIG1hdGNoZWQgdG8gdGhlIGV4YWN0IGZyZXF1ZW5jeSB1c2VkIGluIHlvdXIgbGFiLjwvbGk+CjwvdWw+Cgo=PGgzIGlkPSJnb2dnbGUtdHlwZXMiPjIuIFVuZGVyc3RhbmQgdGhlIERpZmZlcmVudCBDYXRlZ29yaWVzIG9mIEdvZ2dsZXM8L2gzPgoKPHA+VGhlIG1hbnVmYWN0dXJpbmcgcHJvY2VzcyBvZiBnb2dnbGVzIGRpZmZlcnMuIERlcGVuZGluZyBvbiB5b3VyIHVzZSBzaXR1YXRpb24sIHlvdSBtaWdodCByZXF1aXJlOjwvcD4KCjx1bD4KICA8bGk+PHN0cm9uZz5TYWZldHkgZ29nZ2xlcyBmb3IgaW5kaXJlY3QgdmVudHM8L3N0cm9uZz48YnI+CiAgQWxsb3cgYWlyZmxvdyB3aGlsZSBwcmV2ZW50aW5nIGxpcXVpZCBzcGxhc2hlcy48YnI+CiAgUGVyZmVjdCBmb3IgY2hlbWljYWwgbGFib3JhdG9yaWVzLjwvbGk+CgogIDxsaT48c3Ryb25nPlNhZmV0eSBnb2dnbGVzIGZvciBkaXJlY3QgdmVudHM8L3N0cm9uZz48YnI+CiAgSW5jcmVhc2UgYWlyZmxvdyBhcyBtdWNoIGFzIHBvc3NpYmxlIGJ1dCBhdm9pZCBzcGxhc2ggaGF6YXJkcy48YnI+CiAgT25seSB1c2VmdWwgaW4gZHVzdHkgZW52aXJvbm1lbnRzLjwvbGk+CgogIDxsaT48c3Ryb25nPlNhZmV0eSBnb2dnbGVzIHdpdGhvdXQgdmVudHM8L3N0cm9uZz48YnI+CiAgSWRlYWwgZm9yIG1hbmFnaW5nIGV4dHJlbWVseSBoYXphcmRvdXMgb3IgY29ycm9zaXZlIHN1YnN0YW5jZXMuPGJyPgogIExpbWl0ZWQgYWlyZmxvdyBtYWtlcyBpdCBsZXNzIGNvbWZvcnRhYmxlIHRvIHdlYXIgZm9yIGV4dGVuZGVkIHBlcmlvZHMuPC9saT4KCiAgPGxpPjxzdHJvbmc+TGFzZXIgc2FmZXR5IGdvZ2dsZXM8L3N0cm9uZz48YnI+CiAgT2ZmZXIgcHJvdGVjdGlvbiBhZ2FpbnN0IHNwZWNpZmljIGxhc2VyIHdhdmVsZW5ndGhzLjxicj4KICBNdXN0IGJlIG1hdGNoZWQgdG8gdGhlIGV4YWN0IGZyZXF1ZW5jeSB1c2VkIGluIHlvdXIgbGFiLjwvbGk+CjwvdWw+Cgo=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PGgzIGlkPSJidWxrLXB1cmNoYXNpbmciPjguIEJ1bGsgUHVyY2hhc2luZyBSZWNvbW1lbmRhdGlvbnMgZm9yIEIyQiBDdXN0b21lcnM8L2gzPgoKPHA+SW4gdGhlIGV4cGVyaWVuY2Ugb2YgcHVyY2hhc2luZyBQUEUgZm9yIGEgY29tcGFueSB3aXRoIG11bHRpcGxlIGxvY2F0aW9ucywgdGhlIGZvbGxvd2luZyB0aXBzIG9uIHB1cmNoYXNpbmcgaW4gYnVsayBhcmUgYWR2aXNhYmxlOjwvcD4KPHVsPgogIDxsaT5SZXF1ZXN0IHRoZSBBTlNJIHRlc3QgZG9jdW1lbnRhdGlvbiBmcm9tIHZlbmRvcnMuPC9saT4KICA8bGk+UmV2aWV3IHRoZWlyIGZpdCB0ZXN0IHByb2dyYW1zLCBhcyB3ZWxsIGFzIHRoZWlyIHJldHVybiBwb2xpY2llcy48L2xpPgogIDxsaT5EZW1hbmQgdm9sdW1lIGRpc2NvdW50cy48L2xpPgogIDxsaT5TZXQgdXAgYSBQUEUgdHJhY2tpbmcgc3lzdGVtIHRvIG1vbml0b3IgYSBjeWNsZSBvZiB1c2Ugb3IgcmVwbGFjZW1lbnQuPC9saT4KPC91bD4=PGgzIGlkPSJtYWludGVuYW5jZSI+OS4gR3VpZGVsaW5lcyBmb3IgTWFpbnRlbmFuY2UgYW5kIFJlcGxhY2VtZW50PC9oMz4KCjxwPkZvciBzYWZldHkgZ29nZ2xlcyB0byByZW1haW4gT1NIQS1hcHByb3ZlZCB0aGV5IHNob3VsZCBiZTo8L3A+Cjx1bD4KICA8bGk+T25seSBjbG91ZHkgc3VyZmFjZXMsIGNyYWNrcywgb3IgYSBicm9rZW4gc3RyYXAgd2VyZSBpbnNwZWN0ZWQgZm9yIHJlZ3VsYXJseS48L2xpPgogIDxsaT5XaXBlZCBkb3duIGRhaWx5IHdpdGggbGVucy1zYWZlIGRpc2luZmVjdGFudHMuPC9saT4KICA8bGk+SW1tZWRpYXRlbHkgcmVwbGFjZWQgaWYgZGFtYWdlZCBvciBubyBsb25nZXIgZml0cy48L2xpPgo8L3VsPgo8cD5UbyBtYXhpbWl6ZSB1c2FiaWxpdHksIGVtcGxveWVycyBtdXN0IHNldCByZXBsYWNlbWVudCBwZXJpb2RzIChlLmcuIGV2ZXJ5IHNpeCBtb250aHMpIGFuZCBlZHVjYXRlIGVtcGxveWVlcyB0byBtYWludGFpbiB0aGUgcHJvZHVjdHMgZWZmZWN0aXZlbHkuPC9wPgo=PGgyIGlkPSJjb25jbHVzaW9uIj5Db25jbHVzaW9uPC9oMj4KCjxwPkNob29zaW5nIHRoZSByaWdodCBsYWIgc2FmZXR5IGdvZ2dsZXMgaXMgbW9yZSBvZiBhIOKAmHByZXZlbnRpb24gaXMgYmV0dGVyIHRoYW4gY3VyZeKAmSBzdHJhdGVneSB0byB3b3JrcGxhY2Ugc2FmZXR5LCBsZWdhbCBjb21wbGlhbmNlLCBhbmQgZW1wbG95ZWUgcmVhc3N1cmFuY2UsIG5vdCBqdXN0IGFub3RoZXIgaXRlbSBpbiB5b3VyIHRpY2sgYm94IGxpc3QuIElmIHlvdSBrbm93IHlvdXIgaGF6YXJkIHByb2ZpbGUgYW5kIGZvbGxvdyBBTlNJIGd1aWRlbGluZXMsIHlvdSBjYW4gaW52ZXN0IG1vcmUgd2lzZWx5IGluIGV5ZSBwcm90ZWN0aW9uIHdoaWxlIGxlYWRpbmcgd2l0aCBjb21mb3J0IGFuZCBjbGFyaXR5LjwvcD4KCjxwPlRoZSByaWdodCBnb2dnbGVzIGNhbiBkcmFtYXRpY2FsbHkgcmVkdWNlIHRoZSBwb3RlbnRpYWwgZm9yIGluanVyeSBhY3Jvc3MgbWFueSBpbmR1c3RyaWVzIOKAkyBpbmNsdWRpbmcgcGhhcm1hLCBjaGVtaWNhbHMsIFImRCwgYW5kIGJpb3RlY2gg4oCTIGFuZCBzaG93IHlvdXIgc3RhZmYgdGhhdCB5b3UgY2FyZSBhYm91dCB0aGVpciBoZWFsdGggYW5kIHNhZmV0eS48L3A+Cg==