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