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