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