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