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