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