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