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