PCEtLSBUYWJsZSBvZiBDb250ZW50cyBmb3I6IDUgUmVhc29ucyBVbml2ZXJzaXRpZXMgU3RydWdnbGUgd2l0aCBTRFMgQ29tcGxpYW5jZSBhbmQgVGhlaXIgU29sdXRpb25zIC0tPgo8bmF2IGNsYXNzPSJ0b2MiIGFyaWEtbGFiZWw9IlRhYmxlIG9mIGNvbnRlbnRzIGZvciBTRFMgY29tcGxpYW5jZSBhcnRpY2xlIj4KICA8aDI+VGFibGUgb2YgQ29udGVudHM8L2gyPgogIDxvbD4KICAgIDxsaT48YSBocmVmPSIjaW50cm9kdWN0aW9uIj5JbnRyb2R1Y3Rpb248L2E+PC9saT4KICAgIDxsaT4KICAgICAgPGEgaHJlZj0iI3JlYXNvbnMtb3ZlcnZpZXciPjUgUmVhc29ucyBVbml2ZXJzaXRpZXMgU3RydWdnbGUgd2l0aCBTRFMgQ29tcGxpYW5jZSBhbmQgVGhlaXIgU29sdXRpb25zPC9hPgogICAgICA8b2w+CiAgICAgICAgPGxpPgogICAgICAgICAgPGEgaHJlZj0iI3JlYXNvbi0xIj5SZWFzb24gMTogRGVjZW50cmFsaXplZCBDaGVtaWNhbCBNYW5hZ2VtZW50IGFuZCBMYWNrIG9mIENlbnRyYWxpemVkIE92ZXJzaWdodDwvYT4KICAgICAgICAgIDx1bD4KICAgICAgICAgICAgPGxpPjxhIGhyZWY9IiNyZWFzb24tMS1jaGFsbGVuZ2UiPlRoZSBDaGFsbGVuZ2U8L2E+PC9saT4KICAgICAgICAgICAgPGxpPjxhIGhyZWY9IiNyZWFzb24tMS1zb2x1dGlvbiI+VGhlIFNvbHV0aW9uPC9hPjwvbGk+CiAgICAgICAgICAgIDxsaT48YSBocmVmPSIjcmVhc29uLTEtZXhhbXBsZSI+RXhhbXBsZTogVUMgQ2hlbWljYWxzIChVbml2ZXJzaXR5IG9mIENhbGlmb3JuaWEgc3lzdGVtKTwvYT48L2xpPgogICAgICAgICAgPC91bD4KICAgICAgICA8L2xpPgogICAgICAgIDxsaT4KICAgICAgICAgIDxhIGhyZWY9IiNyZWFzb24tMiI+UmVhc29uIDI6IEluYWRlcXVhdGUgU3R1ZGVudCBhbmQgRW1wbG95ZWUgVHJhaW5pbmcgYW5kIEhhemFyZCBDb21tdW5pY2F0aW9uPC9hPgogICAgICAgICAgPHVsPgogICAgICAgICAgICA8bGk+PGEgaHJlZj0iI3JlYXNvbi0yLWNoYWxsZW5nZSI+VGhlIENoYWxsZW5nZTwvYT48L2xpPgogICAgICAgICAgICA8bGk+PGEgaHJlZj0iI3JlYXNvbi0yLXNvbHV0aW9uIj5UaGUgU29sdXRpb248L2E+PC9saT4KICAgICAgICAgICAgPGxpPjxhIGhyZWY9IiNyZWFzb24tMi1leGFtcGxlIj5FeGFtcGxlOiBMTVMtZHJpdmVuIHByb2dyYW1zIChlLmcuLCBTYWZldHlTa2lsbHMsIENsb3VkU0RTIExNUyk8L2E+PC9saT4KICAgICAgICAgIDwvdWw+CiAgICAgICAgPC9saT4KICAgICAgICA8bGk+CiAgICAgICAgICA8YSBocmVmPSIjcmVhc29uLTMiPlJlYXNvbiAzOiBPdXRkYXRlZCBvciBJbmNvbXBsZXRlIFNhZmV0eSBEYXRhIFNoZWV0cyBhbmQgTWFudWFsIFVwZGF0ZSBQcm9jZXNzZXM8L2E+CiAgICAgICAgICA8dWw+CiAgICAgICAgICAgIDxsaT48YSBocmVmPSIjcmVhc29uLTMtY2hhbGxlbmdlIj5UaGUgQ2hhbGxlbmdlPC9hPjwvbGk+CiAgICAgICAgICAgIDxsaT48YSBocmVmPSIjcmVhc29uLTMtc29sdXRpb24iPlRoZSBTb2x1dGlvbjwvYT48L2xpPgogICAgICAgICAgICA8bGk+PGEgaHJlZj0iI3JlYXNvbi0zLWV4YW1wbGUiPkV4YW1wbGU6IENoZW13YXRjaCBhZG9wdGlvbiAoVW5pdmVyc2l0eSBvZiBJb3dhKTwvYT48L2xpPgogICAgICAgICAgPC91bD4KICAgICAgICA8L2xpPgogICAgICAgIDxsaT4KICAgICAgICAgIDxhIGhyZWY9IiNyZWFzb24tNCI+UmVhc29uIDQ6IExpbWl0ZWQgQnVkZ2V0IGFuZCBSZXNvdXJjZXMgZm9yIEVIUyBQcm9ncmFtczwvYT4KICAgICAgICAgIDx1bD4KICAgICAgICAgICAgPGxpPjxhIGhyZWY9IiNyZWFzb24tNC1jaGFsbGVuZ2UiPlRoZSBDaGFsbGVuZ2U8L2E+PC9saT4KICAgICAgICAgICAgPGxpPjxhIGhyZWY9IiNyZWFzb24tNC1zb2x1dGlvbiI+VGhlIFNvbHV0aW9uPC9hPjwvbGk+CiAgICAgICAgICAgIDxsaT48YSBocmVmPSIjcmVhc29uLTQtZXhhbXBsZSI+RXhhbXBsZTogU3R1ZGVudC1sZWQgc3VtbWVyIGludmVudG9yeSB0ZWFtczwvYT48L2xpPgogICAgICAgICAgPC91bD4KICAgICAgICA8L2xpPgogICAgICAgIDxsaT4KICAgICAgICAgIDxhIGhyZWY9IiNyZWFzb24tNSI+UmVhc29uIDU6IENvbXBsZXggUmVndWxhdG9yeSBWYXJpYXRpb25zIGFuZCBNdWx0aS1DYW1wdXMgQ29tcGxpYW5jZSBDaGFsbGVuZ2VzPC9hPgogICAgICAgICAgPHVsPgogICAgICAgICAgICA8bGk+PGEgaHJlZj0iI3JlYXNvbi01LWNoYWxsZW5nZSI+VGhlIENoYWxsZW5nZTwvYT48L2xpPgogICAgICAgICAgICA8bGk+PGEgaHJlZj0iI3JlYXNvbi01LXNvbHV0aW9uIj5UaGUgU29sdXRpb248L2E+PC9saT4KICAgICAgICAgICAgPGxpPjxhIGhyZWY9IiNyZWFzb24tNS1leGFtcGxlIj5FeGFtcGxlOiBDZW50cmFsaXplZCBtdWx0aS1qdXJpc2RpY3Rpb24gc3lzdGVtcyAoZS5nLiwgVUMgQmVya2VsZXkpPC9hPjwvbGk+CiAgICAgICAgICA8L3VsPgogICAgICAgIDwvbGk+CiAgICAgIDwvb2w+CiAgICA8L2xpPgogICAgPGxpPjxhIGhyZWY9IiNjYWxsLXRvLWFjdGlvbiI+Q2FsbCB0byBBY3Rpb248L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjcmVmZXJlbmNlcyI+UmVmZXJlbmNlczwvYT48L2xpPgogIDwvb2w+CjwvbmF2PgoKPCEtLSBTdWdnZXN0ZWQgSURzIHRvIHBsYWNlIG9uIHlvdXIgaGVhZGluZ3MgaW4gdGhlIGFydGljbGUgYm9keToKPGgxIGlkPSJpbnRyb2R1Y3Rpb24iPkludHJvZHVjdGlvbjwvaDE+CjxoMiBpZD0icmVhc29ucy1vdmVydmlldyI+NSBSZWFzb25zIFVuaXZlcnNpdGllcyBTdHJ1Z2dsZSB3aXRoIFNEUyBDb21wbGlhbmNlIGFuZCBUaGVpciBTb2x1dGlvbnM8L2gyPgo8aDMgaWQ9InJlYXNvbi0xIj5SZWFzb24gMTogRGVjZW50cmFsaXplZCBDaGVtaWNhbCBNYW5hZ2VtZW50IGFuZCBMYWNrIG9mIENlbnRyYWxpemVkIE92ZXJzaWdodDwvaDM+CjxoNCBpZD0icmVhc29uLTEtY2hhbGxlbmdlIj5UaGUgQ2hhbGxlbmdlPC9oND4KPGg0IGlkPSJyZWFzb24tMS1zb2x1dGlvbiI+VGhlIFNvbHV0aW9uPC9oND4KPGg1IGlkPSJyZWFzb24tMS1leGFtcGxlIj5FeGFtcGxlOiBVQyBDaGVtaWNhbHMgKFVuaXZlcnNpdHkgb2YgQ2FsaWZvcm5pYSBzeXN0ZW0pPC9oNT4KCjxoMyBpZD0icmVhc29uLTIiPlJlYXNvbiAyOiBJbmFkZXF1YXRlIFN0dWRlbnQgYW5kIEVtcGxveWVlIFRyYWluaW5nIGFuZCBIYXphcmQgQ29tbXVuaWNhdGlvbjwvaDM+CjxoNCBpZD0icmVhc29uLTItY2hhbGxlbmdlIj5UaGUgQ2hhbGxlbmdlPC9oND4KPGg0IGlkPSJyZWFzb24tMi1zb2x1dGlvbiI+VGhlIFNvbHV0aW9uPC9oND4KPGg1IGlkPSJyZWFzb24tMi1leGFtcGxlIj5FeGFtcGxlOiBMTVMtZHJpdmVuIHByb2dyYW1zIChlLmcuLCBTYWZldHlTa2lsbHMsIENsb3VkU0RTIExNUyk8L2g1PgoKPGgzIGlkPSJyZWFzb24tMyI+UmVhc29uIDM6IE91dGRhdGVkIG9yIEluY29tcGxldGUgU2FmZXR5IERhdGEgU2hlZXRzIGFuZCBNYW51YWwgVXBkYXRlIFByb2Nlc3NlczwvaDM+CjxoNCBpZD0icmVhc29uLTMtY2hhbGxlbmdlIj5UaGUgQ2hhbGxlbmdlPC9oND4KPGg0IGlkPSJyZWFzb24tMy1zb2x1dGlvbiI+VGhlIFNvbHV0aW9uPC9oND4KPGg1IGlkPSJyZWFzb24tMy1leGFtcGxlIj5FeGFtcGxlOiBDaGVtd2F0Y2ggYWRvcHRpb24gKFVuaXZlcnNpdHkgb2YgSW93YSk8L2g1PgoKPGgzIGlkPSJyZWFzb24tNCI+UmVhc29uIDQ6IExpbWl0ZWQgQnVkZ2V0IGFuZCBSZXNvdXJjZXMgZm9yIEVIUyBQcm9ncmFtczwvaDM+CjxoNCBpZD0icmVhc29uLTQtY2hhbGxlbmdlIj5UaGUgQ2hhbGxlbmdlPC9oND4KPGg0IGlkPSJyZWFzb24tNC1zb2x1dGlvbiI+VGhlIFNvbHV0aW9uPC9oND4KPGg1IGlkPSJyZWFzb24tNC1leGFtcGxlIj5FeGFtcGxlOiBTdHVkZW50LWxlZCBzdW1tZXIgaW52ZW50b3J5IHRlYW1zPC9oNT4KCjxoMyBpZD0icmVhc29uLTUiPlJlYXNvbiA1OiBDb21wbGV4IFJlZ3VsYXRvcnkgVmFyaWF0aW9ucyBhbmQgTXVsdGktQ2FtcHVzIENvbXBsaWFuY2UgQ2hhbGxlbmdlczwvaDM+CjxoNCBpZD0icmVhc29uLTUtY2hhbGxlbmdlIj5UaGUgQ2hhbGxlbmdlPC9oND4KPGg0IGlkPSJyZWFzb24tNS1zb2x1dGlvbiI+VGhlIFNvbHV0aW9uPC9oND4KPGg1IGlkPSJyZWFzb24tNS1leGFtcGxlIj5FeGFtcGxlOiBDZW50cmFsaXplZCBtdWx0aS1qdXJpc2RpY3Rpb24gc3lzdGVtcyAoZS5nLiwgVUMgQmVya2VsZXkpPC9oNT4KCjxoMiBpZD0iY2FsbC10by1hY3Rpb24iPkNhbGwgdG8gQWN0aW9uPC9oMj4KPGgyIGlkPSJyZWZlcmVuY2VzIj5SZWZlcmVuY2VzPC9oMj4KLS0+Cg==PHNlY3Rpb24gaWQ9ImludHJvZHVjdGlvbiI+CiAgPGgxPkludHJvZHVjdGlvbjwvaDE+CiAgPHA+VW5pdmVyc2l0aWVzIHJlcHJlc2VudCB1bmlxdWUgY2hlbWljYWwgbWFuYWdlbWVudCBlbnZpcm9ubWVudHMuIFVubGlrZSBpbmR1c3RyaWFsIGZhY2lsaXRpZXMgd2l0aCBjZW50cmFsaXplZCBvcGVyYXRpb25zLCBhY2FkZW1pYyBpbnN0aXR1dGlvbnMganVnZ2xlIHRob3VzYW5kcyBvZiBoYXphcmRvdXMgY2hlbWljYWxzIHNwcmVhZCBhY3Jvc3MgZG96ZW5zIG9mIGRlcGFydG1lbnRzLCBsYWJvcmF0b3JpZXMsIGFuZCBmYWNpbGl0aWVzLiBGcm9tIHNjaWVuY2UgbGFicyB0byBhcnQgc3R1ZGlvcywgbWFpbnRlbmFuY2UgY2xvc2V0cyB0byBhdGhsZXRpYyBmYWNpbGl0aWVzLCB0aGUgY2hlbWljYWwgZm9vdHByaW50IGlzIHZhc3QgYW5kIGNvbXBsZXguPC9wPgoKICA8cD5UaGlzIGRpc3RyaWJ1dGVkIG5hdHVyZSBvZiBjaGVtaWNhbCB1c2UsIGNvbWJpbmVkIHdpdGggbGltaXRlZCByZXNvdXJjZXMgYW5kIGV2ZXItY2hhbmdpbmcgcmVndWxhdG9yeSByZXF1aXJlbWVudHMsIGNyZWF0ZXMgc2lnbmlmaWNhbnQgY2hhbGxlbmdlcyBmb3IgbWFpbnRhaW5pbmcgU2FmZXR5IERhdGEgU2hlZXQgKFNEUykgY29tcGxpYW5jZS4gVW5kZXJzdGFuZGluZyB0aGVzZSBvYnN0YWNsZXMgYW5kIGltcGxlbWVudGluZyBzdHJhdGVnaWMgc29sdXRpb25zIGlzIGVzc2VudGlhbCBmb3IgcHJvdGVjdGluZyBzdHVkZW50cywgZmFjdWx0eSwgYW5kIHN0YWZmIHdoaWxlIG1haW50YWluaW5nIHJlZ3VsYXRvcnkgY29tcGxpYW5jZS48L3A+Cjwvc2VjdGlvbj4Khttps://stage.cloudsds.com/wp-content/uploads/2025/11/5-Reasons-Universities-Struggle-with-SDS-Compliance.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
