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