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