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