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