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