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