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