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