Process Safety Management: Everything You Should Know
PG5hdj4KICA8aDI+VGFibGUgb2YgQ29udGVudHM8L2gyPgogIDx1bD4KICAgIDxsaT48YSBocmVmPSIjaW50cm9kdWN0aW9uIj5JbnRyb2R1Y3Rpb248L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjd2hhdC1pcy1wc20iPldoYXQgaXMgUHJvY2VzcyBTYWZldHkgTWFuYWdlbWVudD88L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjZGVmaW5pdGlvbi1zY29wZSI+MS4gRGVmaW5pdGlvbiBhbmQgU2NvcGU8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjaGlzdG9yaWNhbC1ldm9sdXRpb24iPjIuIEhpc3RvcmljYWwgRXZvbHV0aW9uPC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI3doeS1wc20tbWF0dGVycyI+My4gV2h5IFBTTSBNYXR0ZXJzPC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI3BzbS1lbGVtZW50cyI+NC4gVGhlIDE0IEVsZW1lbnRzIG9mIFBTTTwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNpbXBsZW1lbnRhdGlvbi1iZXN0LXByYWN0aWNlcyI+NS4gSW1wbGVtZW50YXRpb24gQmVzdCBQcmFjdGljZXM8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjZ2xvYmFsLXBlcnNwZWN0aXZlcyI+Ni4gQmV5b25kIE9TSEE6IEdsb2JhbCBQZXJzcGVjdGl2ZXM8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjaG93LXRvLWltcGxlbWVudCI+Ny4gSG93IHRvIEltcGxlbWVudCBQcm9jZXNzIFNhZmV0eSBNYW5hZ2VtZW50PzwvYT48L2xpPgogIDwvdWw+CjwvbmF2Pgo=PHNlY3Rpb24gaWQ9ImludHJvZHVjdGlvbiI+CiAgPGgyPkludHJvZHVjdGlvbjwvaDI+CiAgPHA+CiAgICBBdCB0aGUgaGVhcnQgb2Ygcm9idXN0IHByb2Nlc3Mgc2FmZXR5IGxpZXMgdGhyZWUgY3JpdGljYWwsIG9mdGVuIHVuc3Bva2VuLCBwaWxsYXJzOiBpZGVudGlmeWluZyBoYXphcmRzLCBhc3Nlc3Npbmcgcmlza3MsIGFuZCBpbXBsZW1lbnRpbmcgY29udHJvbHMuCiAgICBUaGVzZSBlbGVtZW50cyBhcmUgdml0YWwgYmVjYXVzZSB0aGV5IHByb2FjdGl2ZWx5IHBpbnBvaW50IHBvdGVudGlhbCBkYW5nZXJzLCBldmFsdWF0ZSB0aGVpciBhc3NvY2lhdGVkIHJpc2tzLCBhbmQgZXN0YWJsaXNoIHJvYnVzdCBjb250cm9scywgCiAgICBmb3JtaW5nIGEgY3J1Y2lhbCBmcmFtZXdvcmsgdGhhdCBzYWZlZ3VhcmRzIHdvcmtlcnMsIHByb3RlY3RzIHRoZSBlbnZpcm9ubWVudCwgYW5kIG1haW50YWlucyBvcGVyYXRpb25hbCBpbnRlZ3JpdHkuCiAgPC9wPgogIDxwPgogICAgVGhlIHRyYWdpYyAyMDEzIFdlc3QgRmVydGlsaXplciBleHBsb3Npb24sIHdoaWNoIGtpbGxlZCAxNSBhbmQgaW5qdXJlZCBodW5kcmVkcyBkdWUgdG8gaW1wcm9wZXJseSBzdG9yZWQgYW1tb25pdW0gbml0cmF0ZSwgCiAgICBzdGFya2x5IGlsbHVzdHJhdGVzIGhvdyBuZWdsZWN0aW5nIHRoZXNlIGZ1bmRhbWVudGFscyBjYW4gZGV2YXN0YXRlIGNvbW11bml0aWVzIGFuZCBpbmN1ciBtYXNzaXZlIGNvc3RzLCAKICAgIHVuZGVyc2NvcmluZyB0aGUgcmVhbC13b3JsZCBzdGFrZXMuIFVsdGltYXRlbHksIGZvciBhbnkgb3JnYW5pemF0aW9uIGRlYWxpbmcgd2l0aCA8YSBocmVmPSJodHRwczovL2Nsb3Vkc2RzLmNvbS9jaGVtaWNhbC1oYXphcmQtYW5kLXNhZmV0eS9oYW5kbGluZy1oYXphcmRvdXMtbWF0ZXJpYWxzLWluLXRoZS13b3JrcGxhY2UtYS1jb21wcmVoZW5zaXZlLWd1aWRlLyIgdGFyZ2V0PSJfYmxhbmsiIHJlbD0ibm9vcGVuZXIiPmhhemFyZG91cyBtYXRlcmlhbHM8L2E+LCAKICAgIGRpbGlnZW50IHNhZmV0eSBtYW5hZ2VtZW50IGlzbid0IGp1c3QgZ29vZCBwcmFjdGljZeKAlGl0J3MgYSBtYXR0ZXIgb2YgbGlmZSBhbmQgZGVhdGguCiAgPC9wPgo8L3NlY3Rpb24+Cg==PHNlY3Rpb24gaWQ9IndoYXQtaXMtcHNtIj4KICA8aDI+V2hhdCBpcyBQcm9jZXNzIFNhZmV0eSBNYW5hZ2VtZW50PzwvaDI+CiAgPHA+CiAgICBQcm9jZXNzIFNhZmV0eSBNYW5hZ2VtZW50IChQU00pIGlzIGEgY29tcHJlaGVuc2l2ZSwgc3lzdGVtYXRpYyBhcHByb2FjaCB0byBpZGVudGlmeWluZywgYXNzZXNzaW5nLCBhbmQgY29udHJvbGxpbmcgdGhlIGhhemFyZHMgb2YgcHJvY2Vzc2VzIGludm9sdmluZyAKICAgIGhpZ2hseSBoYXphcmRvdXMgY2hlbWljYWxzLCB3aXRoIHRoZSBnb2FsIG9mIHByZXZlbnRpbmcgY2F0YXN0cm9waGljIHJlbGVhc2VzIGFuZCBzYWZlZ3VhcmRpbmcgcGVvcGxlLCBwcm9wZXJ0eSwgYW5kIHRoZSBlbnZpcm9ubWVudC4KICA8L3A+Cjwvc2VjdGlvbj4=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
Permissible Exposure Limit (PEL): Everything You Need to Know
PG5hdj4KICA8aDI+VGFibGUgb2YgQ29udGVudHM8L2gyPgogIDx1bD4KICAgIDxsaT48YSBocmVmPSIjaW50cm9kdWN0aW9uIj5JbnRyb2R1Y3Rpb248L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjd2hhdC1pcy1wZWwiPldoYXQgaXMgUEVMIGluIFNpbXBsZSBUZXJtcz88L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIja2V5LXBvaW50cyI+S2V5IFBvaW50cyB0byBLbm93IGFib3V0IFBFTDwvYT4KICAgICAgPHVsPgogICAgICAgIDxsaT48YSBocmVmPSIjdHdhIj5UaW1lLVdlaWdodGVkIEF2ZXJhZ2UgKFRXQSk8L2E+PC9saT4KICAgICAgICA8bGk+PGEgaHJlZj0iI3N0ZWwiPlNob3J0LVRlcm0gRXhwb3N1cmUgTGltaXRzIChTVEVMKTwvYT48L2xpPgogICAgICAgIDxsaT48YSBocmVmPSIjY2VpbGluZyI+Q2VpbGluZyBMaW1pdHM8L2E+PC9saT4KICAgICAgPC91bD4KICAgIDwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI2ltcG9ydGFuY2Utb2YtcGVsIj5XaHkgYXJlIFBFTHMgSW1wb3J0YW50PzwvYT4KICAgICAgPHVsPgogICAgICAgIDxsaT48YSBocmVmPSIjcHJvdGVjdHMtaGVhbHRoIj5Qcm90ZWN0cyBXb3JrZXIgSGVhbHRoPC9hPjwvbGk+CiAgICAgICAgPGxpPjxhIGhyZWY9IiNyZWR1Y2VzLWFjY2lkZW50cyI+UmVkdWNlcyBDaGVtaWNhbCBBY2NpZGVudHM8L2E+PC9saT4KICAgICAgICA8bGk+PGEgaHJlZj0iI2xlZ2FsLWNvbXBsaWFuY2UiPkVuc3VyZXMgTGVnYWwgQ29tcGxpYW5jZTwvYT48L2xpPgogICAgICAgIDxsaT48YSBocmVmPSIjc2FmZXR5LWN1bHR1cmUiPkJ1aWxkcyBhIFNhZmV0eS1GaXJzdCBDdWx0dXJlPC9hPjwvbGk+CiAgICAgICAgPGxpPjxhIGhyZWY9IiNkb3dudGltZSI+UHJldmVudHMgQ29zdGx5IERvd250aW1lPC9hPjwvbGk+CiAgICAgIDwvdWw+CiAgICA8L2xpPgogICAgPGxpPjxhIGhyZWY9IiNhcmUtcGVscy11cGRhdGVkIj5BcmUgT1NIQeKAmXMgUEVMcyBVcCB0byBEYXRlPzwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNkaWZmZXJlbnQtbGltaXRzIj5Ib3cgRGlmZmVyZW50IEV4cG9zdXJlIExpbWl0cyBXb3JrPzwvYT4KICAgICAgPHVsPgogICAgICAgIDxsaT48YSBocmVmPSIjbmlvc2gtcmVsIj5OSU9TSCBSRUwgKFJlY29tbWVuZGVkIEV4cG9zdXJlIExpbWl0KTwvYT48L2xpPgogICAgICAgIDxsaT48YSBocmVmPSIjYWNnaWgtdGx2Ij5BQ0dJSCBUTFYgKFRocmVzaG9sZCBMaW1pdCBWYWx1ZSk8L2E+PC9saT4KICAgICAgPC91bD4KICAgIDwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI2FwcGx5LXBlbCI+SG93IHRvIEFwcGx5IFBFTHMgUHJhY3RpY2FsbHkgaW4gWW91ciBGYWNpbGl0eT88L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjdGlwcyI+V2hhdCBTaG91bGQgQ2hlbWljYWwtSGFuZGxpbmcgT3JnYW5pemF0aW9ucyBLbm93OiBGZXcgVGlwczwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNjb25jbHVzaW9uIj5Db25jbHVzaW9uPC9hPjwvbGk+CiAgPC91bD4KPC9uYXY+Cg==PHNlY3Rpb24gaWQ9ImludHJvZHVjdGlvbiI+CiAgPGgyPkludHJvZHVjdGlvbjwvaDI+CiAgPHA+CiAgICBBbGxvd2luZyBjaGVtaWNhbCBleHBvc3VyZSB0byBleGNlZWQgdGhlIFBlcm1pc3NpYmxlIEV4cG9zdXJlIExpbWl0IChQRUwpIGRvZXNu4oCZdCBqdXN0IGVuZGFuZ2VyIHlvdXIgZW1wbG95ZWVzLiAKICAgIEl0IGNhbiBhbHNvIGxlYWQgdG8gcmVndWxhdG9yeSBwZW5hbHRpZXMgYW5kIG5vbmNvbXBsaWFuY2UgaXNzdWVzLiBUaGF04oCZcyB3aHkgeW91ciBvcmdhbml6YXRpb24gbmVlZHMgdG8gc2V0IGNsZWFyIGV4cG9zdXJlIGJvdW5kYXJpZXMuIAogICAgQnV0IHRoZSBwcm9ibGVtIGlzLCBkbyB5b3VyIHNhZmV0eSBtYW5hZ2VycyBmdWxseSB1bmRlcnN0YW5kIHdoYXQgUEVMIG1lYW5zPyBBIHByb3BlciB1bmRlcnN0YW5kaW5nIG9mIFBFTCBpcyBuZWNlc3NhcnksIAogICAgYXMgdGhlaXIga25vd2xlZGdlIGNhbiBwcmV2ZW50IGhlYWx0aCByaXNrcywgd29ya3BsYWNlIGluanVyaWVzLCBhbmQgcG90ZW50aWFsIGNoZW1pY2FsIGFjY2lkZW50cy4KICA8L3A+CgogIDxwPgogICAgRXZlcnkgaGF6YXJkb3VzIGNoZW1pY2FsIHNob3VsZG7igJl0IGJlIGhhbmRsZWQgd2l0aG91dCBwcm9wZXIgY2FyZS4gVGhlIFBFTCBzaW1wbHkgZGVmaW5lcyBob3cgbXVjaCBvZiBhIHN1YnN0YW5jZSB3b3JrZXJzIGNhbiAKICAgIHNhZmVseSBiZSBleHBvc2VkIHRvIHdpdGhpbiBhIHNwZWNpZmljIHRpbWUgZnJhbWUuIEJ1dCBoZXJl4oCZcyB0aGUgY2F0Y2guIFJlZ3VsYXRpb25zIGNhbiBiZSBvdXRkYXRlZCwgYW5kIGV4cG9zdXJlIGxpbWl0cyBhcmUgb2Z0ZW4gbWlzdW5kZXJzdG9vZC4gCiAgICBXaXRob3V0IGNsZWFyIHByb2Nlc3NlcyBhbmQgdXAtdG8tZGF0ZSBrbm93bGVkZ2UsIHlvdXIgb3JnYW5pemF0aW9uIG1heSBiZSB1bmtub3dpbmdseSBwdXR0aW5nIGVtcGxveWVlcyBhdCByaXNrLiAKICAgIE5hdHVyYWxseSwgaXTigJlzIG9wZW5pbmcgaXRzZWxmIHVwIHRvIHNpZ25pZmljYW50IGxpYWJpbGl0eS4KICA8L3A+CgogIDxwPgogICAgU28sIHdoYXQgaXMgdGhlIHNvbHV0aW9uPyBJdCBzdGFydHMgd2l0aCBidWlsZGluZyBzdHJvbmcgYXdhcmVuZXNzIGFjcm9zcyB5b3VyIHRlYW1zLiBNb3Jlb3ZlciwgaXQgaW5jbHVkZXMgZW5zdXJpbmcgdGhhdCBhbGwgeW91ciBtYW5hZ2VycyAKICAgIGhhdmUgMjQvNyBhY2Nlc3MgdG8gYWNjdXJhdGUsIHVwLXRvLWRhdGUgaW5mb3JtYXRpb24gb24gZXhwb3N1cmUgbGltaXRzLgogIDwvcD4KCiAgPHA+CiAgICBUbyBnYWluIGEgdGhvcm91Z2ggdW5kZXJzdGFuZGluZyBvZiB0aGUgcGVybWlzc2libGUgZXhwb3N1cmUgbGltaXQgb2YgY2hlbWljYWwgcHJvZHVjdHMsIGNvbnRpbnVlIHJlYWRpbmcgdGhpcyBndWlkZS4KICA8L3A+Cjwvc2VjdGlvbj4KPHNlY3Rpb24gaWQ9IndoYXQtaXMtcGVsIj4KICA8aDI+V2hhdCBpcyBQRUwgaW4gU2ltcGxlIFRlcm1zPzwvaDI+CiAgPHA+CiAgICBQZXJtaXNzaWJsZSBFeHBvc3VyZSBMaW1pdCwgb3IgUEVMLCBpcyBtYWlubHkgYSBzYWZldHkgZ3VpZGVsaW5lLiBJdCBleHBsYWlucyBob3cgbXVjaCBvZiBhIGNoZW1pY2FsIGEgd29ya2VyIGNhbiBiZSBleHBvc2VkIHRvIGR1cmluZyB0aGVpciB3b3JrZGF5LiAKICAgIEdlbmVyYWxseSwgUEVMIGlzIHNldCBieSBPU0hBIChPY2N1cGF0aW9uYWwgU2FmZXR5IGFuZCBIZWFsdGggQWRtaW5pc3RyYXRpb24pLiBJdHMgcHVycG9zZSBpcyB0byByZWR1Y2UgdGhlIHJpc2sgb2YgY2hlbWljYWwtcmVsYXRlZCBpbGxuZXNzZXMgaW4gdGhlIHdvcmtwbGFjZS4KICA8L3A+CgogIDxoMz5LZXkgUG9pbnRzIHRvIEtub3cgYWJvdXQgUEVMPC9oMz4KICA8cD4KICAgIEdlbmVyYWxseSwgbW9zdCBQRUxzIGFyZSBtZWFzdXJlZCBhcyBhbiBhdmVyYWdlIG92ZXIgYW4gOC1ob3VyIHdvcmsgc2hpZnQuIFRoaXMgaXMgY2FsbGVkIGEgPHN0cm9uZz5UaW1lLVdlaWdodGVkIEF2ZXJhZ2UgKFRXQSk8L3N0cm9uZz4uIAogICAgQmVzaWRlcywgc29tZSBjaGVtaWNhbHMgYWxzbyBoYXZlOgogIDwvcD4KCiAgPGg0IGlkPSJzdGVsIj5pKSBTaG9ydC1UZXJtIEV4cG9zdXJlIExpbWl0cyAoU1RFTCk8L2g0PgogIDxwPgogICAgVGhpcyBpcyB0aGUgYXZlcmFnZSBhbW91bnQgYSB3b3JrZXIgY2FuIGJlIGV4cG9zZWQgdG8gb3ZlciBhIDE1LW1pbnV0ZSBwZXJpb2QuCiAgPC9wPgoKICA8aDQgaWQ9ImNlaWxpbmciPmlpKSBDZWlsaW5nIExpbWl0czwvaDQ+CiAgPHA+CiAgICBUaGUgY2VpbGluZyBsaW1pdHMgaW5kaWNhdGUgYW4gYWJzb2x1dGUgbWF4aW11bSBsZXZlbCB0aGF0IHNob3VsZCBuZXZlciBiZSBleGNlZWRlZCwgbm90IGV2ZW4gZm9yIGEgbW9tZW50LgogIDwvcD4KPC9zZWN0aW9uPgo=PHNlY3Rpb24gaWQ9ImltcG9ydGFuY2Utb2YtcGVsIj4KICA8aDI+V2h5IGFyZSBQRUxzIEltcG9ydGFudD88L2gyPgoKICA8aDMgaWQ9InByb3RlY3RzLWhlYWx0aCI+MS4gUHJvdGVjdHMgV29ya2VyIEhlYWx0aDwvaDM+CiAgPHA+CiAgICBQRUxzIGNhbiBoZWxwIHByZXZlbnQgc2hvcnQtdGVybSBhbmQgbG9uZy10ZXJtIGhlYWx0aCBwcm9ibGVtcy4gQWZ0ZXIgYWxsLCBpdCBsaW1pdHMgaG93IG11Y2ggb2YgYSBjaGVtaWNhbCBhIHdvcmtlciBjYW4gYmUgZXhwb3NlZCB0by4gCiAgICBCcmVhdGhpbmcgYmV5b25kIHRoZSBQRUwgY2FuIGNhdXNlIGhlYWRhY2hlcywgbHVuZyBpc3N1ZXMsIHNraW4gcHJvYmxlbXMsIG9yIHNlcmlvdXMgZGlzZWFzZXMgbGlrZSBjYW5jZXIuCiAgPC9wPgoKICA8aDMgaWQ9InJlZHVjZXMtYWNjaWRlbnRzIj4yLiBSZWR1Y2VzIENoZW1pY2FsIEFjY2lkZW50czwvaDM+CiAgPHA+CiAgICBQRUwgYWxzbyBwbGF5cyBhIHZpdGFsIHJvbGUgaW4gcmVkdWNpbmcgdGhlIGNoYW5jZXMgb2YgY2hlbWljYWwgYWNjaWRlbnRzLiBIb3c/IEFjdHVhbGx5LCB3aGVuIGV4cG9zdXJlIGlzIGNvbnRyb2xsZWQsIAogICAgdGhlIGNoYW5jZXMgb2YgY2hlbWljYWwtcmVsYXRlZCBhY2NpZGVudHMgb3IgZW1lcmdlbmNpZXMgZ28gZG93bi4gQXMgYSByZXN1bHQsIGl0IGhlbHBzIGNyZWF0ZSBhIHNhZmVyIHdvcmsgZW52aXJvbm1lbnQgZm9yIGV2ZXJ5b25lLgogIDwvcD4KCiAgPGgzIGlkPSJsZWdhbC1jb21wbGlhbmNlIj4zLiBFbnN1cmVzIExlZ2FsIENvbXBsaWFuY2U8L2gzPgogIDxwPgogICAgUEVMcyBhcmUgZW5mb3JjZWQgYnkgT1NIQSwgd2hpY2ggaXMgYSBmZWRlcmFsIGFnZW5jeS4gSWYgeW91ciBjb21wYW55IGRvZXNu4oCZdCBmb2xsb3cgdGhlbSwgaXQgY291bGQgZmFjZSBmaW5lcywgaW5zcGVjdGlvbnMsIG9yIGV2ZW4gbGVnYWwgYWN0aW9uLiAKICAgIFN0YXlpbmcgd2l0aGluIHRoZSBsaW1pdHMgaXMgdGhlcmVmb3JlIG1hbmRhdG9yeS4gSXQgY2FuIGtlZXAgeW91ciBvcmdhbml6YXRpb24gY29tcGxpYW50IGFuZCBvdXQgb2YgYWxsIHRyb3VibGVzLgogIDwvcD4KCiAgPGgzIGlkPSJzYWZldHktY3VsdHVyZSI+NC4gQnVpbGRzIGEgU2FmZXR5LUZpcnN0IEN1bHR1cmU8L2gzPgogIDxwPgogICAgQnkgZm9sbG93aW5nIFBFTHMsIHlvdXIgb3JnYW5pemF0aW9uIGNhbiBwcm92ZSBpdHMgY2FyZSBhYm91dCBpdHMgZW1wbG95ZWVzJyBzYWZldHkuIE5hdHVyYWxseSwgaXQgaGVscHMgYnVpbGQgdHJ1c3Qgd2l0aCB5b3VyIHdvcmtmb3JjZS4gCiAgICBCZXNpZGVzLCBpdCBlbmNvdXJhZ2VzIGV2ZXJ5b25lIHRvIGZvbGxvdyBzYWZlIHdvcmsgcHJhY3RpY2VzLgogIDwvcD4KCiAgPGgzIGlkPSJkb3dudGltZSI+NS4gUHJldmVudHMgQ29zdGx5IERvd250aW1lPC9oMz4KICA8cD4KICAgIEF2b2lkaW5nIG92ZXJleHBvc3VyZSBtZWFucyBmZXdlciB3b3JrZXIgaW5qdXJpZXMgb3IgaWxsbmVzc2VzLiBJdCBsZWFkcyB0byBmZXdlciBzaWNrIGRheXMsIGNvbXBlbnNhdGlvbiBjbGFpbXMsIG9yIHNodXRkb3ducy4gCiAgICBUaHVzLCB5b3VyIGNvbXBhbnkgY2FuIHNhdmUgdGltZSBhbmQgbW9uZXkuCiAgPC9wPgo8L3NlY3Rpb24+Cg==PHNlY3Rpb24gaWQ9ImFyZS1wZWxzLXVwZGF0ZWQiPgogIDxoMj5BcmUgT1NIQeKAmXMgUEVMcyBVcCB0byBEYXRlPzwvaDI+CiAgPHA+CiAgICBEaWQgeW91IGtub3cgdGhhdCBtb3N0IG9mIE9TSEHigJlzIFBlcm1pc3NpYmxlIEV4cG9zdXJlIExpbWl0cyAoUEVMcykgd2VyZSBjcmVhdGVkIGJhY2sgaW4gdGhlIGVhcmx5IDE5NzBzPyAKICAgIE1vcmVvdmVyLCB0aGV5IGhhdmVu4oCZdCBjaGFuZ2VkIG11Y2ggc2luY2UgdGhlbi4gRXZlbiBleHBlcnRzIGFsc28gc3VnZ2VzdCB0aGF0IG1hbnkgb2YgdGhlc2UgbGltaXRzIGFyZSBvdXRkYXRlZC4gCiAgICBOYXR1cmFsbHksIHRoZXkgbWF5IG5vdCBvZmZlciBlbm91Z2ggcHJvdGVjdGlvbiBmb3IgdG9kYXnigJlzIHdvcmtlcnMuCiAgPC9wPgoKICA8cD4KICAgIEJlY2F1c2Ugb2YgdGhpcywgbWFueSBzYWZldHkgcHJvZmVzc2lvbmFscyBhbHNvIHJlZmVyIHRvIG90aGVyIGV4cG9zdXJlIGxpbWl0cyBsaWtlIAogICAgPHN0cm9uZz5OSU9TSCBSRUxzPC9zdHJvbmc+IChSZWNvbW1lbmRlZCBFeHBvc3VyZSBMaW1pdHMpIGFuZCA8c3Ryb25nPkFDR0lIIFRMVnM8L3N0cm9uZz4gKFRocmVzaG9sZCBMaW1pdCBWYWx1ZXMpLiAKICAgIFRoZXNlIGxpbWl0cyBhcmVu4oCZdCBsZWdhbGx5IHJlcXVpcmVkIGxpa2UgT1NIQeKAmXMgUEVMcy4gSG93ZXZlciwgdGhleSBhcmUgd2lkZWx5IGNvbnNpZGVyZWQgc2FmZXIgYW5kIG1vcmUgdXAgdG8gZGF0ZS4gCiAgICBTbywgd2hlbiBPU0hBIGxpbWl0cyBmYWxsIHNob3J0LCBvcmdhbml6YXRpb25zIG9mdGVuIHVzZSB0aGVzZSBhbHRlcm5hdGl2ZSBndWlkZWxpbmVzLiBUaGVzZSBndWlkZWxpbmVzIGFsc28gaGVscCBiZXR0ZXIgcHJvdGVjdCB0aGVpciBlbXBsb3llZXMuCiAgPC9wPgo8L3NlY3Rpb24+Cg==PHNlY3Rpb24gaWQ9ImRpZmZlcmVudC1saW1pdHMiPgogIDxoMj5Ib3cgRGlmZmVyZW50IEV4cG9zdXJlIExpbWl0cyBXb3JrPzwvaDI+CiAgPHA+SGVyZeKAmXMgaG93IGRpZmZlcmVudCBleHBvc3VyZSBsaW1pdHMgd29yazo8L3A+CgogIDxoMyBpZD0ibmlvc2gtcmVsIj5pKSBOSU9TSCBSRUwgKFJlY29tbWVuZGVkIEV4cG9zdXJlIExpbWl0KTwvaDM+CiAgPHA+CiAgICBUaGVzZSBhcmUgbWFpbmx5IGhlYWx0aC1iYXNlZCByZWNvbW1lbmRhdGlvbnMuIEl0IGlzIHNldCBieSB0aGUgTmF0aW9uYWwgSW5zdGl0dXRlIGZvciBPY2N1cGF0aW9uYWwgU2FmZXR5IGFuZCBIZWFsdGggKE5JT1NIKS4gCiAgICBUaG91Z2ggbm90IGVuZm9yY2VhYmxlIGJ5IGxhdywgdGhleSBhaW0gdG8gb2ZmZXIgYmV0dGVyIHByb3RlY3Rpb24uIEFjY29yZGluZyB0byBleHBlcnRzLCB0aGVzZSBhcmUgb2Z0ZW4gc3RyaWN0ZXIgdGhhbiBPU0hB4oCZcyBQRUxzLgogIDwvcD4KCiAgPGgzIGlkPSJhY2dpaC10bHYiPmlpKSBBQ0dJSCBUTFYgKFRocmVzaG9sZCBMaW1pdCBWYWx1ZSk8L2gzPgogIDxwPgogICAgRGV2ZWxvcGVkIGJ5IHRoZSBBbWVyaWNhbiBDb25mZXJlbmNlIG9mIEdvdmVybm1lbnRhbCBJbmR1c3RyaWFsIEh5Z2llbmlzdHMsIHRoZXNlIGFyZSBleHBvc3VyZSBsaW1pdHMgYmFzZWQgb24gdGhlIGxhdGVzdCByZXNlYXJjaC4gCiAgICBKdXN0IGxpa2UgTklPU0ggUkVMcywgdGhleeKAmXJlIG5vdCBsZWdhbGx5IGJpbmRpbmcgYnV0IGFyZSB3aWRlbHkgcmVzcGVjdGVkIGFuZCB1c2VkIGFzIGluZHVzdHJ5IGJlc3QgcHJhY3RpY2VzLgogIDwvcD4KPC9zZWN0aW9uPgo=PHNlY3Rpb24gaWQ9ImFwcGx5LXBlbCI+CiAgPGgyPkhvdyB0byBBcHBseSBQRUxzIFByYWN0aWNhbGx5IGluIFlvdXIgRmFjaWxpdHk/PC9oMj4KCiAgPGgzPkxpc3QgYWxsIENoZW1pY2FscyBpbiBVc2Ugb3IgU3RvcmFnZTwvaDM+CiAgPHA+CiAgICBTdGFydCBieSBpZGVudGlmeWluZyBldmVyeSBjaGVtaWNhbCB1c2VkIG9yIHN0b3JlZCBpbiB5b3VyIGZhY2lsaXR5LiAKICAgIFRoaXMgZ2l2ZXMgeW91IGEgZnVsbCBwaWN0dXJlIG9mIHBvdGVudGlhbCBleHBvc3VyZSByaXNrcy4KICA8L3A+CgogIDxoMz5SZWZlciB0byBPZmZpY2lhbCBFeHBvc3VyZSBMaW1pdHM8L2gzPgogIDxwPgogICAgQ2hlY2sgT1NIQeKAmXMgWi10YWJsZXMgb3IgQ2FsL09TSEEgVGFibGUgQUMtMSAoVGFibGUgNTE1NSkgdG8gZmluZCB0aGUgUEVMcyBmb3IgZWFjaCBjaGVtaWNhbCB5b3VyIHRlYW0gaGFuZGxlcy4KICA8L3A+CgogIDxoMz5Db21wYXJlIHdpdGggVXBkYXRlZCBSZWNvbW1lbmRhdGlvbnM8L2gzPgogIDxwPgogICAgTG9vayBhdCBOSU9TSCBSRUxzIGFuZCBBQ0dJSCBUTFZzIHRvby4gVGhlc2UgYXJlIHVwZGF0ZWQgbW9yZSBmcmVxdWVudGx5IHRoYW4gT1NIQSBQRUxzLiAKICAgIE1vcmVvdmVyLCBpdCBjYW4gb2ZmZXIgYmV0dGVyIHByb3RlY3Rpb27igJRlc3BlY2lhbGx5IGZvciBtb3JlIGRhbmdlcm91cyBzdWJzdGFuY2VzLgogIDwvcD4KCiAgPGgzPk1vbml0b3IgRXhwb3N1cmUgTGV2ZWxzPC9oMz4KICA8cD4KICAgIFVzZSBhaXIgc2FtcGxpbmcgdG9vbHMgb3IgcmVhbC10aW1lIHNlbnNvcnMgdG8gbWVhc3VyZSBob3cgbXVjaCBvZiBhIGNoZW1pY2FsIGlzIGluIHRoZSBhaXIuIAogICAgVGhpcyBoZWxwcyB5b3Ugc3RheSBhd2FyZSBvZiBjdXJyZW50IGV4cG9zdXJlIGNvbmRpdGlvbnMuCiAgPC9wPgoKICA8aDM+Q29udHJvbCBFeHBvc3VyZSB3aGVuIE5lZWRlZDwvaDM+CiAgPHA+SWYgbGV2ZWxzIGFyZSBoaWdoLCBhY3Q6PC9wPgogIDx1bD4KICAgIDxsaT5Vc2UgZW5naW5lZXJpbmcgY29udHJvbHMgKGxpa2UgcHJvcGVyIHZlbnRpbGF0aW9uKTwvbGk+CiAgICA8bGk+UHJvdmlkZSBQUEUgKG1hc2tzLCBnbG92ZXMsIGV0Yy4pPC9saT4KICAgIDxsaT5BcHBseSBhZG1pbmlzdHJhdGl2ZSBjb250cm9scyAobGlrZSBqb2Igcm90YXRpb24gb3IgbGltaXRpbmcgZXhwb3N1cmUgdGltZSk8L2xpPgogIDwvdWw+CgogIDxoMz5UcmFjayBhbmQgUmV2aWV3IFJlZ3VsYXJseTwvaDM+CiAgPHA+CiAgICBNYWtlIGV4cG9zdXJlIHRyYWNraW5nIHBhcnQgb2YgeW91ciBzYWZldHkgcm91dGluZS4gCiAgICBSZWd1bGFyIGF1ZGl0cyBoZWxwIGVuc3VyZSB5b3UncmUgc3RheWluZyBjb21wbGlhbnQgYW5kIHNwb3R0aW5nIHJpc2tzIGVhcmx5LgogIDwvcD4KPC9zZWN0aW9uPgo=PHNlY3Rpb24gaWQ9InRpcHMiPgogIDxoMj5XaGF0IFNob3VsZCBDaGVtaWNhbC1IYW5kbGluZyBPcmdhbml6YXRpb25zIEtub3c6IEZldyBUaXBzPC9oMj4KICA8dWw+CiAgICA8bGk+T1NIQSBQRUxzIGFyZSB0aGUgbWluaW11bSBsZWdhbCBzdGFuZGFyZCwgYnV0IHRoZXkgYXJlIG9mdGVuIG5vdCBlbm91Z2guPC9saT4KICAgIDxsaT5Db25zaWRlciBtb3JlIHByb3RlY3RpdmUgbGltaXRzIGZyb20gTklPU0ggYW5kIEFDR0lILjwvbGk+CiAgICA8bGk+RG9jdW1lbnQgZXhwb3N1cmUgYXNzZXNzbWVudHMgYW5kIGludGVydmVudGlvbnMgYXMgcGFydCBvZiByZWd1bGF0b3J5IGNvbXBsaWFuY2UuPC9saT4KICAgIDxsaT5UcmFpbiBzdGFmZiBvbiBQRUwgZGVmaW5pdGlvbnMsIG1vbml0b3JpbmcgbWV0aG9kcywgYW5kIHJlc3BvbnNlIGFjdGlvbnMuPC9saT4KICAgIDxsaT5SZWd1bGFybHkgcmV2aWV3IFNEU3MgZm9yIHVwZGF0ZXMgb24gZXhwb3N1cmUgbGltaXRzIG9yIGhhemFyZCBkZXNpZ25hdGlvbnMuPC9saT4KICA8L3VsPgo8L3NlY3Rpb24+Cg==PHNlY3Rpb24gaWQ9ImNvbmNsdXNpb24iPgogIDxoMj5Db25jbHVzaW9uPC9oMj4KICA8cD4KICAgIEZvciBsYWJzIG9yIGFueSBmYWNpbGl0aWVzIGhhbmRsaW5nIGNoZW1pY2FscywgdW5kZXJzdGFuZGluZyBQRUxzIGlzIG1hbmRhdG9yeS4gCiAgICBNb3Jlb3ZlciwgaXTigJlzIGEgY29yZSBzYWZldHkgcmVzcG9uc2liaWxpdHkuIEl04oCZcyB0aGUgYmFzZWxpbmUgZm9yIGRlY2lzaW9uc+KAlAogICAgZnJvbSB2ZW50aWxhdGlvbiBzeXN0ZW0gdXBncmFkZXMgdG8gcHJvY3VyaW5nIHNhZmVyIGFsdGVybmF0aXZlcyBvciBQUEUuCiAgPC9wPgogIDxwPgogICAgQWx0aG91Z2ggT1NIQSBzZXRzIHRoZSBtaW5pbXVtLCB0cnVlIHNhZmV0eSBvZnRlbiBkZW1hbmRzIGdvaW5nIGFib3ZlIGFuZCBiZXlvbmQuIAogICAgU28sIGFsc28gZ2FpbiBhIHRob3JvdWdoIHVuZGVyc3RhbmRpbmcgb2YgUkVMcyBvciBUTFZzIHRvIG1haW50YWluIHZpZ2lsYW50IG1vbml0b3JpbmcgYW5kIGNvbnRyb2xzLgogIDwvcD4KPC9zZWN0aW9uPgo=
Handling Hazardous Materials in the Workplace: A Comprehensive Guide
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PHNlY3Rpb24gaWQ9IndoeS1oYW5kbGluZy1oYXphcmRvdXMtbWF0ZXJpYWxzLWlzLWEtdG9wLWIyYi1wcmlvcml0eSI+CiAgPGgyPldoeSBIYW5kbGluZyBIYXphcmRvdXMgTWF0ZXJpYWxzIGlzIGEgVG9wIEIyQiBQcmlvcml0eTwvaDI+CiAgPHA+CiAgICBJbiBCMkIgc2V0dGluZ3MsIGVzcGVjaWFsbHkgaW4gbWFudWZhY3R1cmluZywgd2FyZWhvdXNpbmcsIGxvZ2lzdGljcywgYW5kIGhlYWx0aGNhcmUsIHRoZSByaXNrIHNjYWxlcyB3aXRoIHZvbHVtZS4gQSBzbWFsbCBtaXNoYXAgY2FuIGxlYWQgdG86CiAgPC9wPgogIDx1bD4KICAgIDxsaT5Xb3JrcGxhY2UgaW5qdXJpZXMgb3IgZmF0YWxpdGllczwvbGk+CiAgICA8bGk+UmVndWxhdG9yeSBmaW5lcyAoT1NIQSwgRVBBLCBET1QsIGxvY2FsIGFnZW5jaWVzKTwvbGk+CiAgICA8bGk+UHJvZHVjdGlvbiBkb3dudGltZTwvbGk+CiAgICA8bGk+QnJhbmQgZGFtYWdlIGFuZCBsYXdzdWl0czwvbGk+CiAgICA8bGk+RW52aXJvbm1lbnRhbCBjb250YW1pbmF0aW9uPC9saT4KICA8L3VsPgogIDxwPgogICAgQnV5ZXJzLCBmYWNpbGl0eSBtYW5hZ2VycywgRUhTIG9mZmljZXJzLCBhbmQgc2FmZXR5IGRlY2lzaW9uLW1ha2VycyBtdXN0IGFsaWduIG9uIHN0YW5kYXJkaXplZCBzYWZldHkgcHJvdG9jb2xzLCBiYWNrZWQgYnkgZGF0YSwgdHJhaW5pbmcsIGFuZCBtb2Rlcm4gdG9vbHMuCiAgPC9wPgo8L3NlY3Rpb24+Cg==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PHNlY3Rpb24gaWQ9ImNvbW1vbi1oYXptYXQtZXJyb3JzIj4KICA8aDI+Q29tbW9uIEhhem1hdCBFcnJvcnMgdG8gQXZvaWQgaW4gV29ya3BsYWNlIEVudmlyb25tZW50czwvaDI+CiAgPHA+CiAgICBDb3N0bHkgbWlzdGFrZXMgYXJlIG1hZGUgYnkgZXZlbiBleHBlcmllbmNlZCB0ZWFtcy4gS2VlcCBhbiBleWUgb3V0IGZvcjoKICA8L3A+CiAgPHVsPgogICAgPGxpPk1pc3Npbmcgb3Igb3V0ZGF0ZWQgU0RTcy48L2xpPgogICAgPGxpPkluYWNjdXJhdGUgbGFiZWxpbmcgb2Ygc2Vjb25kYXJ5IGNvbnRhaW5lcnMuPC9saT4KICAgIDxsaT5LZWVwaW5nIHN1YnN0YW5jZXMgdGhhdCBhcmUgaW5jb21wYXRpYmxlIHRvZ2V0aGVyLjwvbGk+CiAgICA8bGk+Tm90IHByb3ZpZGluZyB0cmFpbmluZyB0byB0ZW1wb3JhcnkgZW1wbG95ZWVzIG9yIG5ldyBoaXJlcy48L2xpPgogICAgPGxpPlBvb3IgdmVudGlsYXRpb24gb3IgaW1wcm9wZXIgdXNlIG9mIHBlcnNvbmFsIHByb3RlY3RpdmUgZXF1aXBtZW50LjwvbGk+CiAgICA8bGk+SGF6YXJkb3VzIHdhc3RlIGltcHJvcGVybHkgZGlzcG9zZWQgb2YuPC9saT4KICA8L3VsPgogIDxwPgogICAgQW55IG9mIHRoZXNlIGNvdWxkIGxlYWQgdG8gYWN0dWFsIHNhZmV0eSByZXBlcmN1c3Npb25zLCBsZWdhbCBhY3Rpb24sIGFuZCByZWd1bGF0b3J5IGF1ZGl0cy4KICA8L3A+Cjwvc2VjdGlvbj4KPHNlY3Rpb24gaWQ9ImVocy1zb2Z0d2FyZS1iZW5lZml0cyI+CiAgPGgyPkhvdyBFSFMgU29mdHdhcmUgU2ltcGxpZmllcyBIYXptYXQgTWFuYWdlbWVudDwvaDI+CiAgPHA+CiAgICBTcHJlYWRzaGVldHMgYW5kIG1hbnVhbCB0cmFja2luZyBhcmUgbm8gbG9uZ2VyIHN1ZmZpY2llbnQuIE9yZ2FuaXphdGlvbnMgYmVuZWZpdCBmcm9tIGRpZ2l0YWwgRUhTIHBsYXRmb3JtczoKICA8L3A+CiAgPHVsPgogICAgPGxpPktlZXAgeW91ciBTRFMgZGF0YWJhc2VzIGN1cnJlbnQuPC9saT4KICAgIDxsaT5UcmFjayBjaGVtaWNhbCBpbnZlbnRvcmllcyBhdXRvbWF0aWNhbGx5LjwvbGk+CiAgICA8bGk+Q3JlYXRlIGNvbXBsaWFuY2UgcmVwb3J0cyBpbnN0YW50bHkuPC9saT4KICAgIDxsaT5TZXQgcmVhY3Rpdml0eSBhbmQgc2hlbGYtbGlmZSBhbGVydHMuPC9saT4KICAgIDxsaT5Bc3NpZ24gcmVtZWRpYWwgbWVhc3VyZXMgYW5kIHRyYWNrIHRoZWlyIGNvbXBsZXRpb24uPC9saT4KICA8L3VsPgogIDxwPgogICAgRUhTIG1hbmFnZXJzIGNhbiBjb25jZW50cmF0ZSBvbiBzdHJhdGVnaWMgcmlzayByZWR1Y3Rpb24gdGhhbmtzIHRvIHRoZXNlIHN5c3RlbXMsIHdoaWNoIGFsc28gaW1wcm92ZSB0cmFuc3BhcmVuY3kgYW5kIGRlY3JlYXNlIGh1bWFuIGVycm9yLgogIDwvcD4KPC9zZWN0aW9uPgo=PHNlY3Rpb24gaWQ9ImVzZy1hbmQtc3VzdGFpbmFiaWxpdHkiPgogIDxoMj5FU0cgYW5kIFN1c3RhaW5hYmlsaXR5OiBIYXptYXQgU2FmZXR5IFdvcmtzIGFzIGEgRGlmZmVyZW50aWF0b3I8L2gyPgogIDxwPgogICAgRW52aXJvbm1lbnRhbCwgc29jaWFsLCBhbmQgZ292ZXJuYW5jZSAoRVNHKSBwZXJmb3JtYW5jZSBpcyBhIG11c3QgZm9yIHRvZGF5J3MgYnVzaW5lc3MtdG8tYnVzaW5lc3MgKEIyQikgYnV5ZXJzIGFuZCBzdGFrZWhvbGRlcnMuIAogICAgU2FmZSBoYW5kbGluZyBvZiBoYXphcmRvdXMgbWF0ZXJpYWxzOgogIDwvcD4KICA8dWw+CiAgICA8bGk+TG93ZXJzIHRoZSByaXNrIHRvIHRoZSBlbnZpcm9ubWVudC48L2xpPgogICAgPGxpPlByZXNlcnZlcyB0aGUgd2VsbGJlaW5nIG9mIGVtcGxveWVlcy48L2xpPgogICAgPGxpPkV4aGliaXRzIHByb2FjdGl2ZSBhZGhlcmVuY2UgdG8gc3Rha2Vob2xkZXJzIGFuZCBhdWRpdHMuPC9saT4KICAgIDxsaT5Cb29zdHMgY29uc3VtZXIgdHJ1c3QgYW5kIGJyYW5kIHJlcHV0YXRpb24uPC9saT4KICA8L3VsPgogIDxwPgogICAgU2FmZXR5IHByb2NlZHVyZXMgY2FuIG1ha2Ugb3IgYnJlYWsgYSBkZWFsIGluIFJGUXMsIFJGUHMsIGFuZCBzdXBwbGllciBhdWRpdHMuCiAgPC9wPgo8L3NlY3Rpb24+Cg==PHNlY3Rpb24gaWQ9ImZpbmFsLXRob3VnaHRzIj4KICA8aDI+RmluYWwgVGhvdWdodHM8L2gyPgogIDxwPgogICAgRUhTIGRlcGFydG1lbnRzIGFyZSBub3Qgc29sZWx5IHJlc3BvbnNpYmxlIGZvciB0aGUgc2FmZXR5IG9mIGhhemFyZG91cyBtYXRlcmlhbHMuIAogICAgSXQgbmVlZHMgdG8gYmUgaW50ZWdyYXRlZCBpbnRvIGxlYWRlcnNoaXAsIHB1cmNoYXNpbmcsIGludmVudG9yeSwgYW5kIG9wZXJhdGlvbnMuIAogICAgQjJCIGNvbXBhbmllcyB0aGF0IGFkb3B0IGEgcHJvYWN0aXZlLCB0ZWNobm9sb2dpY2FsbHkgYWR2YW5jZWQsIGFuZCB0cmFpbmluZy1yaWNoIHN0cmF0ZWd5IAogICAgd2lsbCBzdXJwYXNzIHJpdmFscyBpbiBhZGRpdGlvbiB0byByZW1haW5pbmcgY29tcGxpYW50LgogIDwvcD4KPC9zZWN0aW9uPgo=
A Comprehensive Guide on Chlorine Including Its Hazard, Safety, and Usage
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PGgyIGlkPSJlbnZpcm9ubWVudGFsLWltcGFjdC1tYW5hZ2VtZW50Ij5FbnZpcm9ubWVudGFsIEltcGFjdCBNYW5hZ2VtZW50PC9oMj4KCgo8aDMgaWQ9ImVtaXNzaW9uLWNvbnRyb2wiPjEuIEVtaXNzaW9uIENvbnRyb2w8L2gzPgo8cD5JbmR1c3RyaWFsIGZhY2lsaXRpZXMgaW1wbGVtZW50IG11bHRpcGxlIHN0cmF0ZWdpZXM6PC9wPgo8dWw+CiAgPGxpPjxzdHJvbmc+QWJzb3JwdGlvbiBzeXN0ZW1zOjwvc3Ryb25nPiBDYXVzdGljIHNjcnViYmluZyBmb3IgY2hsb3JpbmUgZ2FzIHJlbGVhc2VzPC9saT4KICA8bGk+PHN0cm9uZz5MZWFrIGRldGVjdGlvbjo8L3N0cm9uZz4gQ29udGludW91cyBtb25pdG9yaW5nIHRvIG1pbmltaXplIGZ1Z2l0aXZlIGVtaXNzaW9uczwvbGk+CiAgPGxpPjxzdHJvbmc+UHJvY2VzcyBvcHRpbWl6YXRpb246PC9zdHJvbmc+IFJlZHVjaW5nIGNobG9yaW5lIGNvbnN1bXB0aW9uIHRocm91Z2ggaW1wcm92ZWQgZWZmaWNpZW5jeTwvbGk+CjwvdWw+Cgo8aDMgaWQ9Indhc3RlLW1hbmFnZW1lbnQiPjIuIFdhc3RlIE1hbmFnZW1lbnQ8L2gzPgo8cD5DaGxvcmluZS1jb250YWluaW5nIHdhc3RlcyByZXF1aXJlIHNwZWNpYWxpemVkIGhhbmRsaW5nIHVuZGVyIGhhemFyZG91cyB3YXN0ZSByZWd1bGF0aW9uczo8L3A+Cjx1bD4KICA8bGk+PHN0cm9uZz5DaGFyYWN0ZXJpemF0aW9uOjwvc3Ryb25nPiBQcm9wZXIgaWRlbnRpZmljYXRpb24gYW5kIGNsYXNzaWZpY2F0aW9uIG9mIGNobG9yaW5lIHdhc3RlczwvbGk+CiAgPGxpPjxzdHJvbmc+VHJlYXRtZW50Ojwvc3Ryb25nPiBOZXV0cmFsaXphdGlvbiBhbmQgc2FmZSBkaXNwb3NhbCBtZXRob2RzPC9saT4KICA8bGk+PHN0cm9uZz5SZXBvcnRpbmc6PC9zdHJvbmc+IENvbXBsaWFuY2Ugd2l0aCByZWxlYXNlIHJlcG9ydGluZyByZXF1aXJlbWVudHM8L2xpPgo8L3VsPgoKPGgzIGlkPSJzdXN0YWluYWJsZS1hbHRlcm5hdGl2ZXMiPjMuIFN1c3RhaW5hYmxlIEFsdGVybmF0aXZlczwvaDM+CjxwPkluZHVzdHJpZXMgYXJlIGV4cGxvcmluZyBhbHRlcm5hdGl2ZXMgdG8gcmVkdWNlIGNobG9yaW5lIGRlcGVuZGVuY3k6PC9wPgo8dWw+CiAgPGxpPjxzdHJvbmc+T24tc2l0ZSBnZW5lcmF0aW9uOjwvc3Ryb25nPiBFbGVjdHJvbHl0aWMgcHJvZHVjdGlvbiByZWR1Y2luZyB0cmFuc3BvcnRhdGlvbiByaXNrczwvbGk+CiAgPGxpPjxzdHJvbmc+QWx0ZXJuYXRpdmUgZGlzaW5mZWN0YW50czo8L3N0cm9uZz4gVVYsIG96b25lLCBhbmQgY2hsb3JpbmUgZGlveGlkZSBmb3Igc3BlY2lmaWMgYXBwbGljYXRpb25zPC9saT4KICA8bGk+PHN0cm9uZz5Qcm9jZXNzIG1vZGlmaWNhdGlvbnM6PC9zdHJvbmc+IENobG9yaW5lLWZyZWUgYmxlYWNoaW5nIGFuZCBtYW51ZmFjdHVyaW5nIHByb2Nlc3NlczwvbGk+CjwvdWw+Cg==PGgyIGlkPSJjb25jbHVzaW9uIj5Db25jbHVzaW9uPC9oMj4KCjxwPgogIFRoZSBrZXkgdG8gc2FmZSBjaGxvcmluZSB1c2UgbGllcyBpbiB1bmRlcnN0YW5kaW5nIGl0cyBwcm9wZXJ0aWVzLCBpbXBsZW1lbnRpbmcgY29tcHJlaGVuc2l2ZSBzYWZldHkgbWVhc3VyZXMsIG1haW50YWluaW5nIHByb3BlciBlcXVpcG1lbnQsCiAgYW5kIGZvc3RlcmluZyBhIGN1bHR1cmUgb2Ygc2FmZXR5IGF3YXJlbmVzcy4gV2hpbGUgYWx0ZXJuYXRpdmVzIGNvbnRpbnVlIHRvIGRldmVsb3AsIGNobG9yaW5lJ3MgZWZmZWN0aXZlbmVzcywgcmVsaWFiaWxpdHksIGFuZCBjb3N0LWVmZmljaWVuY3kKICBlbnN1cmUgaXRzIGNvbnRpbnVlZCBpbXBvcnRhbmNlIGluIHdhdGVyIHRyZWF0bWVudCBhbmQgaW5kdXN0cmlhbCBhcHBsaWNhdGlvbnMuCjwvcD4KCjxwPgogIFN1Y2Nlc3MgaW4gY2hsb3JpbmUgbWFuYWdlbWVudCByZXF1aXJlcyBiYWxhbmNpbmcgaXRzIHRyZW1lbmRvdXMgYmVuZWZpdHMgd2l0aCByaWdvcm91cyByaXNrIG1hbmFnZW1lbnQuIFRocm91Z2ggcHJvcGVyIGVkdWNhdGlvbiwgZXF1aXBtZW50LAogIHByb2NlZHVyZXMsIGFuZCByZWd1bGF0b3J5IG92ZXJzaWdodCwgaW5kdXN0cmllcyBjYW4gaGFybmVzcyBjaGxvcmluZSBjYXBhYmlsaXRpZXMgd2hpbGUgcHJvdGVjdGluZyBodW1hbiBoZWFsdGggYW5kIHRoZSBlbnZpcm9ubWVudC4gQXMgdGVjaG5vbG9neQogIGFkdmFuY2VzIGFuZCByZWd1bGF0aW9ucyBldm9sdmUsIHRoZSBjaGxvcmluZSBpbmR1c3RyeSBtdXN0IGFkYXB0IHdoaWxlIG1haW50YWluaW5nIGl0cyBmdW5kYW1lbnRhbCBjb21taXRtZW50IHRvIHNhZmV0eSBhbmQgcmVzcG9uc2libGUgc3Rld2FyZHNoaXAuCjwvcD4KCjxwPgogIFRoZSBjb21wcmVoZW5zaXZlIGFwcHJvYWNoIG91dGxpbmVkIGluIHRoaXMgZ3VpZGXigJRlbmNvbXBhc3NpbmcgaGF6YXJkIHJlY29nbml0aW9uLCBzYWZldHkgcHJvdG9jb2xzLCBlbWVyZ2VuY3kgcHJlcGFyZWRuZXNzLCBhbmQgcmVndWxhdG9yeSBjb21wbGlhbmNl4oCUCiAgcHJvdmlkZXMgdGhlIGZvdW5kYXRpb24gZm9yIHNhZmUgYW5kIGVmZmVjdGl2ZSBjaGxvcmluZSB1c2UgYWNyb3NzIGFsbCBhcHBsaWNhdGlvbnMuIEJ5IGFkaGVyaW5nIHRvIHRoZXNlIHByaW5jaXBsZXMgYW5kIHJlbWFpbmluZyB2aWdpbGFudCBhYm91dCBlbWVyZ2luZwogIHJpc2tzIGFuZCB0ZWNobm9sb2dpZXMsIG9yZ2FuaXphdGlvbnMgY2FuIGNvbnRpbnVlIHRvIGJlbmVmaXQgZnJvbSBjaGxvcmluZSBjYXBhYmlsaXRpZXMgd2hpbGUgc2FmZWd1YXJkaW5nIGFsbCBzdGFrZWhvbGRlcnMuCjwvcD4K
Category 4 Flammable Liquids: All You Need to Know
PG5hdj4KICA8aDI+VGFibGUgb2YgQ29udGVudHM8L2gyPgogIDx1bD4KICAgIDxsaT48YSBocmVmPSIjb3ZlcnZpZXciPkNhdGVnb3J5IDQgRmxhbW1hYmxlIExpcXVpZHM6IEEgQnJpZWYgT3ZlcnZpZXc8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjZGVmaW5pdGlvbiI+MS4gRGVmaW5pdGlvbiBhbmQgQ2xhc3NpZmljYXRpb248L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjbGFiZWxsaW5nIj4yLiBMYWJlbGxpbmcgUmVxdWlyZW1lbnRzPC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI2hhemFyZHMiPjMuIEhhemFyZHMgYW5kIENvbnRyb2xzPC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI3N0b3JhZ2UiPjQuIFN0b3JhZ2UgUmVxdWlyZW1lbnRzPC9hPgogICAgICA8dWw+CiAgICAgICAgPGxpPjxhIGhyZWY9IiNvc2hhIj40LjEgT1NIQSAyOSBDRlIgMTkxMC4xMDYgKEdlbmVyYWwgSW5kdXN0cnkpPC9hPjwvbGk+CiAgICAgICAgPGxpPjxhIGhyZWY9IiNuZnBhIj40LjIgTkZQQSAzMCAoRmxhbW1hYmxlIGFuZCBDb21idXN0aWJsZSBMaXF1aWRzIENvZGUpPC9hPjwvbGk+CiAgICAgIDwvdWw+CiAgICA8L2xpPgogICAgPGxpPjxhIGhyZWY9IiNoYW5kbGluZyI+NS4gSGFuZGxpbmcgUHJhY3RpY2VzPC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI3JlZ3VsYXRvcnkiPjYuIFJlZ3VsYXRvcnkgQ29udGV4dDwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNzdW1tYXJ5Ij43LiBTdW1tYXJ5IG9mIEtleSBMaW1pdHM8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjY29uY2x1c2lvbiI+Q29uY2x1c2lvbjwvYT48L2xpPgogIDwvdWw+CjwvbmF2Pgo=<section id="introduction">
  <p>Talk about being everywhere – from the gas in your tank to the perfume on your dresser. Flammable liquids are truly ubiquitous in our lives, making them one of the most common hazardous chemicals we encounter daily. Just think about it: gasoline, industrial solvents like toluene, your favorite cosmetics, or even that high-proof liquor at home all fall squarely into this group, posing a hidden fire risk if not handled right.</p>
  <p>To ensure everyone's on the same page, the internationally recognized <strong><a href="https://cloudsds.com/ghs-system/a-detail-guide-on-ghs-hazard-statements-list-cloudsds/" target="_blank">GHS system</a></strong> precisely defines these liquids as having a flash point not exceeding 93°C, meticulously categorizing them into four distinct groups based on their specific flash point and initial boiling point data. Understanding these classifications is absolutely key to safely navigating a world where these potent liquids are constantly present.</p>
</section>

<section id="overview">
  <h2>Category 4 Flammable Liquids: A Brief Overview</h2>
  <p>Category 4 flammable liquids are those with closed-cup flash points above 60&nbsp;&deg;C (140&nbsp;&deg;F) and at or below 93&nbsp;&deg;C (199.4&nbsp;&deg;F). They present a combustible hazard—not the same as more volatile Category 1–3 flammables—and are subject to specific labeling, handling, storage, and regulatory requirements to manage their fire risk safely.</p>
</section>

<section id="definition">
  <h2>1. Definition and Classification</h2>
  <p>Under the Globally Harmonized System (GHS) and U.S. OSHA’s HazCom standard (29 CFR 1910.106):</p>
  <ul>
    <li><strong>Category 4:</strong> liquids with flash point &gt; 60&nbsp;&deg;C (140&nbsp;&deg;F) and &le; 93&nbsp;&deg;C (199.4&nbsp;&deg;F).</li>
    <li>Flash points are measured via standard closed-cup methods (e.g., ASTM D93).</li>
  </ul>
  <table border="1" cellpadding="5">
    <thead>
      <tr>
        <th>Category</th>
        <th>Flash Point</th>
        <th>Initial Boiling Point</th>
      </tr>
    </thead>
    <tbody>
      <tr><td>1</td><td>&lt; 23&nbsp;&deg;C (73&nbsp;&deg;F)</td><td>&le; 35&nbsp;&deg;C (95&nbsp;&deg;F)</td></tr>
      <tr><td>2</td><td>&lt; 23&nbsp;&deg;C (73&nbsp;&deg;F)</td><td>&gt; 35&nbsp;&deg;C (95&nbsp;&deg;F)</td></tr>
      <tr><td>3</td><td>&ge; 23&nbsp;&deg;C (73&nbsp;&deg;F) and &le; 60&nbsp;&deg;C (140&nbsp;&deg;F)</td><td>-</td></tr>
      <tr><td>4</td><td>&gt; 60&nbsp;&deg;C (140&nbsp;&deg;F) and &le; 93&nbsp;&deg;C (199.4&nbsp;&deg;F)</td><td>-</td></tr>
    </tbody>
  </table>
  <p><strong>Note:</strong> Liquids with flash points above 93&nbsp;&deg;C are not classified as flammable under GHS.</p>
  <p>Examples of Category 4 liquids include diesel fuel, fuel oils with moderate flash points, and some lubricating oils.</p>
</section>

<section id="labelling">
  <h2>2. Labelling Requirements</h2>
  <ul>
    <li><strong>Signal word:</strong> Warning</li>
    <li><strong>Pictogram:</strong> Not required for Category 4</li>
    <li><strong>Hazard statement:</strong> “Combustible liquid” (H227)</li>
    <li><strong>Precautionary statements:</strong> Keep away from heat, sparks, open flames, and hot surfaces.</li>
  </ul>
</section>

<section id="hazards">
  <h2>3. Hazards and Controls</h2>
  <p>Category 4 liquids generate combustible vapors near their flash points. When heated within 16.7&nbsp;&deg;C (30&nbsp;&deg;F) of their flash point, they must be handled like Category 3 flammables.</p>
  <h3>Engineering Controls and PPE</h3>
  <ul>
    <li>Use general/local exhaust ventilation to keep vapor below 25% of the LFL.</li>
    <li>Closed transfer systems, grounding and bonding.</li>
    <li>Store in NFPA 30-rated fire-resistant cabinets or rooms.</li>
    <li>Wear flame-resistant lab coats, chemical-resistant gloves, and safety goggles or face shields.</li>
  </ul>
</section>

<section id="storage">
  <h2>4. Storage Requirements</h2>
  <section id="osha">
    <h3>4.1 OSHA 29 CFR 1910.106 (General Industry)</h3>
    <ul>
      <li>Incidental storage: up to 120 gal per fire area.</li>
      <li>Portable tanks (≤ 660 gal): max 120 gal per tank.</li>
      <li>Cabinets: max 120 gal per cabinet; max 3 cabinets per fire area without fire suppression.</li>
      <li>Inside storage rooms must follow NFPA 30 standards.</li>
    </ul>
  </section>
  <section id="nfpa">
    <h3>4.2 NFPA 30 (Combustible Liquids Code)</h3>
    <ul>
      <li>One cabinet may contain up to 120 gal of Class IIIB (GHS Cat 4).</li>
      <li>Separate from oxidizers by 25 ft or fire-rated partition.</li>
    </ul>
  </section>
</section>

<section id="handling">
  <h2>5. Handling Practices</h2>
  <ul>
    <li>Minimize heating near flash point; apply Category 3 controls if within 30&nbsp;&deg;F.</li>
    <li>Use spark-proof equipment and wiring.</li>
    <li>Transfer via closed systems, self-closing valves, or approved cans.</li>
    <li>No compressed air transfers.</li>
    <li>Clean spills immediately. Store containers closed and upright.</li>
    <li>Post “No Smoking” signage. Prohibit ignition sources nearby.</li>
  </ul>
</section>

<section id="regulatory">
  <h2>6. Regulatory Context</h2>
  <ul>
    <li><strong><a href="https://cloudsds.com/osha-regulations/the-impact-of-oshas-updated-hazcom-standard-on-businesses/" target="_blank">OSHA HazCom</a>:</strong> aligns with GHS for flammables ≤ 93&nbsp;&deg;C.</li>
    <li><strong>DOT (49 CFR 173.120):</strong> defines liquids &lt; 60&nbsp;&deg;C flash point as flammable; Category 4 as “combustible.”</li>
    <li><strong>EU CLP:</strong> does not adopt GHS Category 4. Liquids &gt; 60&nbsp;&deg;C flash point not classified as flammable.</li>
  </ul>
</section>

<section id="summary">
  <h2>7. Summary of Key Limits</h2>
  <table border="1" cellpadding="5">
    <thead>
      <tr>
        <th>Requirement</th>
        <th>Category 4 Liquids</th>
      </tr>
    </thead>
    <tbody>
      <tr><td>Flash point range</td><td>&gt; 60&nbsp;&deg;C and &le; 93&nbsp;&deg;C</td></tr>
      <tr><td>Label hazard statement</td><td>“Combustible liquid”</td></tr>
      <tr><td>Signal word</td><td>Warning</td></tr>
      <tr><td>Max in storage cabinet</td><td>120 gal</td></tr>
      <tr><td>Incidental storage (outside)</td><td>120 gal per fire area</td></tr>
      <tr><td>Portable tank limit</td><td>120 gal per portable tank (≤ 660 gal capacity)</td></tr>
      <tr><td>Separation from oxidizers</td><td>&ge; 25 ft or fire-rated partition</td></tr>
    </tbody>
  </table>
</section>

<section id="conclusion">
  <h2>Conclusion</h2>
  <p>Effectively minimizing fire risks hinges on understanding the characteristics and regulatory framework of Category 4 flammable liquids. Implementing the following is imperative:</p>
  <ul>
    <li>Proper labeling</li>
    <li>Controlled storage environments</li>
    <li>Robust ventilation systems</li>
    <li>Strict adherence to safe handling protocols</li>
  </ul>
  <p>Substances like diesel and lubricating oils, when exposed to elevated temperatures, pose significant risks. Strict compliance not only meets regulations but also ensures workplace safety—preventing catastrophic fires and explosions.</p>
</section>

A Detailed Guide on California OSHA First Aid Kit Requirements
PCEtLSBUYWJsZSBvZiBDb250ZW50cyAtLT4KPGRpdiBjbGFzcz0idGFibGUtb2YtY29udGVudHMiPgogIDxoMj5UYWJsZSBvZiBDb250ZW50czwvaDI+CiAgPG9sPgogICAgPGxpPjxhIGhyZWY9IiNyZWd1bGF0b3J5LWZyYW1ld29yayI+UmVndWxhdG9yeSBGcmFtZXdvcms8L2E+CiAgICAgIDxvbD4KICAgICAgICA8bGk+PGEgaHJlZj0iI2NhbG9zaGEtdGl0bGUtOC0zNDAwLW1lZGljYWwtc2VydmljZXMtYW5kLWZpcnN0LWFpZCI+MS4xIENhbC9PU0hBIFRpdGxlIDggwqczNDAwIOKAnE1lZGljYWwgU2VydmljZXMgYW5kIEZpcnN0IEFpZOKAnTwvYT48L2xpPgogICAgICAgIDxsaT48YSBocmVmPSIjYW5zaS16MzA4MS0yMDIxLW1pbmltdW0tcmVxdWlyZW1lbnRzLWZvci13b3JrcGxhY2UtZmlyc3QtYWlkLWtpdHMiPjEuMiBBTlNJIFozMDguMS0yMDIxIOKAnE1pbmltdW0gUmVxdWlyZW1lbnRzIGZvciBXb3JrcGxhY2UgRmlyc3QtQWlkIEtpdHPigJ08L2E+PC9saT4KICAgICAgPC9vbD4KICAgIDwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI2ZpcnN0LWFpZC1raXQtY2xhc3NpZmljYXRpb25zLWFuZC1jb250ZW50cyI+Rmlyc3QgQWlkIEtpdCBDbGFzc2lmaWNhdGlvbnMgYW5kIENvbnRlbnRzPC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI2FwcHJvdmFsLWluc3BlY3Rpb24tYW5kLW1haW50ZW5hbmNlIj5BcHByb3ZhbCwgSW5zcGVjdGlvbiwgYW5kIE1haW50ZW5hbmNlPC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI3NwZWNpYWwtY29uc2lkZXJhdGlvbnMiPlNwZWNpYWwgQ29uc2lkZXJhdGlvbnM8L2E+CiAgICAgIDxvbD4KICAgICAgICA8bGk+PGEgaHJlZj0iI2hpZ2gtcmlzay1lbnZpcm9ubWVudHMiPjQuMSBIaWdoLVJpc2sgRW52aXJvbm1lbnRzPC9hPjwvbGk+CiAgICAgICAgPGxpPjxhIGhyZWY9IiN0cmFpbmluZy1hbmQtZW1lcmdlbmN5LWFjY2VzcyI+NC4yIFRyYWluaW5nIGFuZCBFbWVyZ2VuY3kgQWNjZXNzPC9hPjwvbGk+CiAgICAgIDwvb2w+CiAgICA8L2xpPgogICAgPGxpPjxhIGhyZWY9IiNlbXBsb3llci1iZXN0LXByYWN0aWNlcyI+RW1wbG95ZXIgQmVzdCBQcmFjdGljZXM8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjY29uY2x1c2lvbiI+Q29uY2x1c2lvbjwvYT48L2xpPgogIDwvb2w+CjwvZGl2Pgo= While the Occupational Safety and Health Administration (OSHA) unequivocally mandates that employers provide a workplace that is both safe and healthy, reasonably free from occupational hazards, it concurrently recognizes the unavoidable reality that accidents can still occur, thus necessitating robust medical and first aid provisions. Indeed, despite diligent adherence to safety protocols and the […]
Carbonyl Chloride Guide: Usage, Hazards, and Safety
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PHNlY3Rpb24gaWQ9InN0b3JhZ2UiPgogIDxoMj5TdG9yYWdlIGFuZCBUcmFuc3BvcnRhdGlvbiBTYWZldHk8L2gyPgoKICA8aDM+YS4gU3RvcmFnZSBSZXF1aXJlbWVudHM8L2gzPgogIDxwPjxzdHJvbmc+Q29udGFpbmVyIFNwZWNpZmljYXRpb25zOjwvc3Ryb25nPiBQaG9zZ2VuZSBpcyBzdG9yZWQgaW4gc3BlY2lhbGx5IGRlc2lnbmVkIHN0ZWVsIGN5bGluZGVycyB3aXRoIENHQS0xNjAgdmFsdmUgb3V0bGV0cyBpbiB0aGUgVVMuPC9wPgoKICA8cD48c3Ryb25nPlN0b3JhZ2UgQ29uZGl0aW9uczo8L3N0cm9uZz48L3A+CiAgPHVsPgogICAgPGxpPktlZXAgY29udGFpbmVycyB0aWdodGx5IGNsb3NlZDwvbGk+PGJyPgogICAgPGxpPlN0b3JlIGluIGNvb2wsIHdlbGwtdmVudGlsYXRlZCBhcmVhczwvbGk+PGJyPgogICAgPGxpPlByb3RlY3QgZnJvbSBtb2lzdHVyZSBhbmQgaW5jb21wYXRpYmxlIG1hdGVyaWFsczwvbGk+PGJyPgogICAgPGxpPk1haW50YWluIHRlbXBlcmF0dXJlcyBiZWxvdyA1MMKwQyB0byBwcmV2ZW50IHByZXNzdXJlIGJ1aWxkdXA8L2xpPgogIDwvdWw+PGJyPgoKICA8aDM+Yi4gVHJhbnNwb3J0YXRpb24gUmVndWxhdGlvbnM8L2gzPgogIDxwPlBob3NnZW5lIHRyYW5zcG9ydCBpcyByZWd1bGF0ZWQgdW5kZXIgdmFyaW91cyBpbnRlcm5hdGlvbmFsIGZyYW1ld29ya3M6PC9wPgogIDx1bD4KICAgIDxsaT48c3Ryb25nPlVOIE51bWJlcjo8L3N0cm9uZz4gMTA3NjwvbGk+PGJyPgogICAgPGxpPjxzdHJvbmc+SGF6YXJkIENsYXNzOjwvc3Ryb25nPiBUb3hpYyBnYXM8L2xpPjxicj4KICAgIDxsaT48c3Ryb25nPlByb3BlciBTaGlwcGluZyBOYW1lOjwvc3Ryb25nPiBQaG9zZ2VuZTwvbGk+PGJyPgogICAgPGxpPlRyYW5zcG9ydCB0eXBpY2FsbHkgb2NjdXJzIHVuZGVyIHN0cmljdCBzYWZldHkgcHJvdG9jb2xzIGR1ZSB0byBleHRyZW1lIHRveGljaXR5PC9saT4KICA8L3VsPjxicj4KCiAgPGgzPmMuIENoZW1pY2FsIFdlYXBvbnMgQ29udmVudGlvbiBDb21wbGlhbmNlPC9oMz4KICA8cD4KICAgIEFzIGEgU2NoZWR1bGUgMyBzdWJzdGFuY2UgdW5kZXIgdGhlIENoZW1pY2FsIFdlYXBvbnMgQ29udmVudGlvbiwgcGhvc2dlbmUgcHJvZHVjdGlvbiBmYWNpbGl0aWVzIG1hbnVmYWN0dXJpbmcgbW9yZSB0aGFuIAogICAgPHN0cm9uZz4zMCB0b25uZXMgYW5udWFsbHk8L3N0cm9uZz4gbXVzdCBiZSBkZWNsYXJlZCB0byB0aGUgCiAgICA8c3Ryb25nPk9yZ2FuaXNhdGlvbiBmb3IgdGhlIFByb2hpYml0aW9uIG9mIENoZW1pY2FsIFdlYXBvbnMgKE9QQ1cpPC9zdHJvbmc+LgogIDwvcD4KPC9zZWN0aW9uPgo=PHNlY3Rpb24gaWQ9ImRpc3Bvc2FsIj4KICA8aDI+V2FzdGUgRGlzcG9zYWwgYW5kIEVudmlyb25tZW50YWwgQ29uc2lkZXJhdGlvbnM8L2gyPgoKICA8aDM+YS4gRGlzcG9zYWwgUHJvdG9jb2xzPC9oMz4KICA8cD5QaG9zZ2VuZSB3YXN0ZSBkaXNwb3NhbCBmb2xsb3dzIHN0cmljdCByZWd1bGF0b3J5IGd1aWRlbGluZXM6PC9wPgogIDx1bD4KICAgIDxsaT5OZXV0cmFsaXphdGlvbiB3aXRoIGFsa2FsaW5lIHNvbHV0aW9ucyAoc29kaXVtIGh5ZHJveGlkZSkgYmVmb3JlIGRpc3Bvc2FsPC9saT48YnI+CiAgICA8bGk+VHJlYXRtZW50IHRocm91Z2ggYXV0aG9yaXplZCBoYXphcmRvdXMgd2FzdGUgZmFjaWxpdGllczwvbGk+PGJyPgogICAgPGxpPkNvbXBsaWFuY2Ugd2l0aCBsb2NhbCBhbmQgbmF0aW9uYWwgZW52aXJvbm1lbnRhbCByZWd1bGF0aW9uczwvbGk+PGJyPgogICAgPGxpPkRvY3VtZW50YXRpb24gYW5kIHRyYWNraW5nIHRocm91Z2hvdXQgdGhlIGRpc3Bvc2FsIHByb2Nlc3M8L2xpPgogIDwvdWw+PGJyPgoKICA8aDM+Yi4gRW52aXJvbm1lbnRhbCBJbXBhY3Q8L2gzPgogIDxwPjxzdHJvbmc+QXRtb3NwaGVyaWMgQnJlYWtkb3duOjwvc3Ryb25nPiBTbWFsbCBhbW91bnRzIG9mIHBob3NnZW5lIG9jY3VyIG5hdHVyYWxseSBmcm9tIHRoZSBicmVha2Rvd24gb2Ygb3JnYW5vY2hsb3JpbmUgY29tcG91bmRzLiBUaGUgY29tcG91bmQgaHlkcm9seXplcyByZWFkaWx5IGluIHRoZSBwcmVzZW5jZSBvZiBtb2lzdHVyZSwgZm9ybWluZyBoeWRyb2NobG9yaWMgYWNpZCBhbmQgY2FyYm9uIGRpb3hpZGUuPC9wPjxicj4KCiAgPHA+PHN0cm9uZz5XYXRlciBDb250YW1pbmF0aW9uIFJpc2s6PC9zdHJvbmc+IFBob3NnZW5lIGlzIHVubGlrZWx5IHRvIGNvbnRhbWluYXRlIHdhdGVyIHNvdXJjZXMgZHVlIHRvIHJhcGlkIGh5ZHJvbHlzaXMgdXBvbiBjb250YWN0IHdpdGggd2F0ZXIuPC9wPgo8L3NlY3Rpb24+Cg==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
A Detailed Guide on OSHA Chemical Hygiene Plan
A Chemical Hygiene Plan (CHP) is a mandatory written program required by the Occupational Safety and Health Administration (OSHA) for all employers engaged in laboratory use of hazardous chemicals. The plan establishes policies, procedures, and responsibilities designed to protect workers from health hazards associated with hazardous chemicals in laboratory environments. Since its implementation in 1990, […]
Class 3 Flammable Liquid: A Detailed Guide by CloudSDS
Class 3 flammable liquids are among the most commonly transported and stored hazardous materials worldwide. These substances are defined as liquids having a flash point of not more than 60°C (140°F) or any material in a liquid phase with a flash point at or above 37.8°C (100°F) that is intentionally heated and transported at or […]
A Detailed Guide on Class 1 Flammable Liquids
Class 1 flammable liquids represent the most hazardous category of flammable liquids, characterized by their extremely low flash points and high volatility. These liquids pose significant fire and explosion risks in workplace environments and require specialized handling, storage, and safety protocols to prevent accidents. Class 1 Flammable Liquids: Definition and Classification Class 1 flammable liquids […]