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