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