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