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