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