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