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