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