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