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