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