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