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