R2F0ZSBXYWxsZXQgQm91bnR5RHJvcDogRG9lIG1lZSBhYW4gZGUgRm9sa3MgQWlyZHJvcCBlbiBkZWVsICQyMCwwMDAgRk9MS1MtdG9rZW4gJiBwdW50ZW4=

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