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