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