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