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