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