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