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