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